Free references software for linux

Web Reference Database is a bibliographic manager that can import and export references in various formats (including BibTeX, Endnote, MODS XML, and OpenOffice).
It can make formatted lists of citations in HTML, RTF, PDF, or LaTeX, and offers powerful searching, rich metadata, and RSS support
Enhancements:
- This release offers major function enhancements and bugfixes.
- Batch import from various bibliographic formats (including BibTeX, Endnote, RIS, ISI, and MODS XML) is now supported, as is import from a PubMed ID.
- An OpenDocument spreadsheet for use with OpenOffice.org can be exported, and formatted citation lists can be generated as HTML, RTF, PDF, or LaTeX. An SRU/W service and support for unAPI, OpenURL, and COinS metadata have been added.
- These allow the data to be used by the next generation of bibliographic clients.
- A new command line client is also included.

RefKeep project is a personal bibliography assistant.
RefKeep is software targeted at teachers, students, and researchers -- people who read and manage a large number of books, journals, magazines, and papers regularly.
It is a tool to manage ones research and other bibliographic information.
Main features:
- Organize and maintain bibliographic information (books, journals, series, papers etc) in the form of RefCollections.
- Search your bibliographic information with ease.
- Generate Reference lists in various formats (HTML, plain text, custom defined formats). For example, a professor can generate easily generate a list of references to be put up on a course website.
- Insert references (citations) of bibliographic sources in a variety of formats with ease. For example, you can insert a reference to a particular paper you read into the latex file or MS Word document you are editing.
- Keep track of books, journals, etc borrowed from your personal collection.
- Create annotated RefLinks between any type of records.
- Each record can be associated with comments/annotations. Separate Note records can also be maintained.
- Easy import and export of records, facilating seamless sharing of data between persons. For example, a grad student can send some interesting RefKeep records in his collection to his advisor through email.
- In the future: Integration with a research project management system, course grading system, access RefCollections over the internet, Use/Import existing bibtex citation repositories.
Enhancements:
- Fixed Import/Export bug (Null pointer exception when no paper source files involved in Export)
- Fixed bug in Saving RefCollections (entities like & in RefCollection details are okay now)
- Fixed bug in Import (If you cancel the Save required while importing records into a brand new (previously un saved) RefCollection, the Import process also aborts)
- Reduced Splash Screen display time from 10 seconds to 4 seconds.
- Fixed bug in saving RefCollections with filenames containing .s
- Fixed bug while un-choosing Source, Authors etc.

refbase is a Web-based multi-user interface for managing scientific literature and bibliographic references. It offers powerful search engine and automatically generated citation lists.
Main features:
- search the database using different search forms
- search within results
- browse found records and view selected records in detail
- display rich text (i.e. italics, super/sub-script, greek letters)
- extract literature cited within a text
- track queries using RSS
- a print-friendly view
- display the selected records in different citation formats
- user specific fields which are stored individually for each user
- display or search within only the users own literature
- export selected records to MODS XML and (via the GPLed bibutils programs) to BibTex, EndNote, and RIS
- automatic email announcements for newly added records
- save and recall search queries
- adding records to user-specific groups
- add/edit/delete records as well as file upload & download links
- import of full records from Cambridge Scientific Abstracts
- user management interface provided to the database admin
- set access permissions on a per-user basis
- People with access to a shell on the refbase server can use the tools in the contrib/endnote directory to batch transfer many records from Endnote into refbase.

Regexp::Parser::Handlers is a Perl module with handlers for Perl 5 regexes.

This module holds the init() method for the Regexp::Parser class, which installs all the handlers for standard Perl 5 regexes. This documentation contains a sub-classing tutorial.

SUB-CLASSING

I will present two example sub-classes, Regexp::NoCode, and Regexp::AndBranch.

Parser Internals

The parser object is a hash reference with the following keys:

regex

A reference to the original string representation of the regex.

len

The length of the original string representation of the regex.

tree

During the first pass, tree is undef, which instructs the object() method not to actually create any objects. Afterwards, it is an array reference of (node) objects.

stack

Initially an array reference, used to store the tree as a new scope is entered and then exited. The general concept is:

if (into_scope) {
push STACK, TREE;
TREE = CURRENT->DATA;
}
if (outof_scope) {
TREE = pop STACK;
}

After the tree has been created, this key is deleted; this gives the code a way to be sure compilation was successful.

maxpar

The highest number of parentheses. It will end up being identical to nparen, but it is incremented during the initial pass, so that on the second pass (the tree-building), it can distinguish back-references from octal escapes. (The source code to Perls regex compiler does the same thing.)

nparen

The number of OPENs (capturing groups) in the regex.

captures

An array reference to the open nodes.

flags

An array reference of flag values. When a scope is entered, the top value is copied and pushed onto the stack. When a scope is left, the top value is popped and discarded.

It is important to do this copy-and-push before you do any flag-parsing, if youre adding a handle that might parse flags, because you do not want to accidentally affect the previous scopes flag values.

Here is example code from the handler for (?ismx) and (?ismx:...):

# (?i:...) {next} }, qw< c) atom >;
}

for (split //, $on) {
if (my $h = $S->can("FLAG_$_")) {
my $v = $h->(1); # 1 means this is on
if ($v) { &Rf |= $v } # turn the flag on
else { ... } # the flags value is 0
next;
}
# throw an error if the flag isnt supported
}

for (map "FLAG_$_", split //, $off) {
if (my $h = $S->can("FLAG_$_")) {
my $v = $h->(0); # 0 means this is off
if ($v) { &Rf &= ~$v } # turn the flag off
else { ... } # the flags value is 0
next;
}
# throw an error if the flag isnt supported
}

Youll probably not be adding handlers that have to parse flags, but if you do, remember to follow this model correctly.

next

An array reference of what handles (or "rules") to try to match next.

Redirection Tool is a product for Plone used for storing references to moved content to enable redirects.
The Redirection Tool can be used for storing references to moved content to enable redirects, or it can be used for giving objects multiple URLs (aliases). If a page is not found, the tool looks at its list of redirects to see if there is a match, and if so, it redirects to that page.
Future plans include a more intelligent 404 handling, where the tool would either search for alternative pages based on the components of the requested URL and automatically redirect if there is only one hit, otherwise display a limited number of hits, or alternatively chop off URL components until it finds an object that can be published to the user.
Enhancements:
- Added Plone 2.1 compatibility.

Perl6::Parameters is a module with Perl 6-style prototypes with named parameters.

SYNOPSIS

use Perl6::Parameters;

sub mysub($foo, ARRAY $bar, *%rest) {
...
}

DETAILS

Perl6::Parameters is a Perl module which simulates Perl 6s named parameters. (When I talk about "named parameters" I mean something like the parameters youre used to from C, Java and many other languages--not pass-a-hash-with-the-parameters-in-it things.)

Like most other programming languages, Perl 6 will support subroutines with pre-declared variables the parameters are put into. (Using this will be optional, however.) This goes far beyond the "line-noise prototypes" available in Perl 5, which only allow you to control context and automatically take references to some parameters--lines like my($first, $second)=(@_) will no longer be necessary.

Although Perl 6 will have this, Perl 5 doesnt; this module makes it so that Perl 5 does. It uses some other Perl 6-isms too, notably the names for builtin types and the unary-asterisk notation for flattening a list.

Crafting Parameter Lists

Crafting parameter lists is simple; just declare your subroutine and put the parameters separated by commas or semicolons, in parenthesis. (Using a semicolon signifies that all remaining parameters are optional; this may not be available this way in Perl 6, but Im assuming it is until I hear otherwise.)

Most parameters are just variable names like $foo; however, more sophisticated behavior is possible. There are three ways to achieve this.

The first way is by specifying a type for the variable. Certain types make the actual parameters turn into references to themselves:

ARRAY $foo

This turns an array into a reference to itself and stores the reference into $foo.

HASH $foo

This turns a hash into a reference to itself and stores the reference into $foo.

CODE $foo

This turns a subroutine into a reference to itself and stores the reference into $foo.

SCALAR $foo

This turns a scalar into a reference to itself and stores the reference into $foo.

GLOB $foo

This turns a typeglob into a reference to itself and stores the reference into $foo. Typeglobs will be going away in Perl 6; this type exists in this module so that its useful for general use in Perl 5.

REF $foo

This turns any parameter into a reference to itself and stores it into $foo.

This only works in Perl 5.8. Otherwise, its treated the same as any other unrecognized type name.

AnythingElse $foo

This has no effect in this module; its treated as though youd typed $foo without the AnythingElse.

For example, if a subroutine had the parameters ($foo, HASH $bar, CODE $baz) and was called with ($scalar, %hash, &mysub) the subroutine would get the contents of $scalar, a reference to %hash and a reference to &mysub.
The second way is by supplying an actual array or hash as a parameter name. This requires an array or hash to be passed in for that parameter; it preserves the length of the array or hash.

The final way is only available for the last parameter: if an array or hash is prefixed with an asterisk, that array or hash will be filled with any additional parameters.

Rubber is a program whose purpose is to handle all tasks related to the compilation of LaTeX documents. Rubber includes compiling the document itself, of course, enough times so that all references are defined, and running BibTeX to manage bibliographic references.

Automatic execution of dvips to produce PostScript documents is also included, as well as usage of pdfLaTeX to produce PDF documents.

The purpose of Rubber is to make the building of a document automated, from the source files to the final document file, replacing the work of a Makefile.

The basis is a routine that compiles a LaTeX source the right number of times to resolve all references and make all tables of contents, list of figures, and so on. On top of that, Rubber provides a modular system to handle various tasks needed apart from compilations.

This, for instance, includes processing bibliographic references or indices, as well as compilation or conversion of figures. Additionally, modules can perform a post-processing of the document (for instance to convert a DVI to PostScript or PDF) or even a preprocessing (useful when the LaTeX source is generated by another program, like cweave).

Dependency analysis is performed by parsing the source files, so that modifying any source, user package, graphics file or other dependency leads to appropriate compilations. Modules are triggered either explicitly using command-line options, or implicitly when the sources are parsed.

For instance, BibTeX support is activated whenever the source contains commands that generate a bibliography, graphics support is activated by usepackage{graphics} and similar commands, and so on. The modular approach allows any additional feature to be supported by simply writing a module to support it.

Dead Link Check (DLC) is a Perl script designed to find information on validity of HTTP references. The script may use/generate a cache file for avoiding redoing network requests if the user wants to check added entries. The script works by reading entries from a file (or a list of links from the command line) and output results in file(s) (or STDOUT). DLC was created as an extension to Public Bookmark Generator (PBM), but can be used on its own.
DLC is as an extension to Public Bookmark Generator (PBM), but can be used by itself.
DLC uses Perl 5 and libwww-perl.
a CPAN archive : ftp://www.perl.com/pub/perl/CPAN/modules/
For installation instructions, please see INSTALL.
For use instructions, please refer to the manpages, perldoc, or launch
the scripts without arguments.
Enhancements:
- Added the "Content" option (beta) to process content of HTML results for possible page not found errors and user moved.
- Added the "Dif" option for not printing the DLC information into HTML generated code.
- Bug fix in environment variables proxy use.
- Bug fix in lowercased URLs redirections.
- Bug fix in generation of empty files.