Free export references software for linux

XML::DOM::EntityReference is an XML ENTITY reference in XML::DOM.

XML::DOM::EntityReference extends XML::DOM::Node.

EntityReference objects may be inserted into the structure model when an entity reference is in the source document, or when the user wishes to insert an entity reference. Note that character references and references to predefined entities are considered to be expanded by the HTML or XML processor so that characters are represented by their Unicode equivalent rather than by an entity reference.

Moreover, the XML processor may completely expand references to entities while building the structure model, instead of providing EntityReference objects. If it does provide such objects, then for a given EntityReference node, it may be that there is no Entity node representing the referenced entity; but if such an Entity exists, then the child list of the EntityReference node is the same as that of the Entity node. As with the Entity node, all descendants of the EntityReference are readonly.

The resolution of the children of the EntityReference (the replacement value of the referenced Entity) may be lazily evaluated; actions by the user (such as calling the childNodes method on the EntityReference node) are assumed to trigger the evaluation.

GENE Graph Export Engine is an advanced XML exporter.
GENE Graph Export Engine is a complex convertor/framework for multi-namespace XML transforming and exporting.
It is able to convert various XML types including SVG, DocBook, MathML, XSL-FO, and their combinations into a wide area of output formats: PDF, PNG, SVG, PS, MIF, RTF, and XHTML.
Custom XSLT scripts can be registered easily and are used automatically. It requires Sun JRE 5.0.
Enhancements:
- GENE Core bugfixes. FOP plugin bugfixes.
- Gene Runner I18N support has been added. l12n in Slovak.
- Configuration ability has been added.
- New command line switches have been added.
- Preliminary buggy CML (Chemical Markup Language) and XHTML->DocBook exporters have been added.

Perl6::Export::Attrs - the Perl 6 is export(...) trait as a Perl 5 attribute.
SYNOPSIS
package Some::Module;
use Perl6::Export::Attrs;
# Export &foo by default, when explicitly requested,
# or when the :ALL export set is requested...
sub foo :Export(:DEFAULT) {
print "phooo!";
}
# Export &var by default, when explicitly requested,
# or when the :bees, :pubs, or :ALL export set is requested...
# the parens after is export are like the parens of a qw(...)
sub bar :Export(:DEFAULT :bees :pubs) {
print "baaa!";
}
# Export &baz when explicitly requested
# or when the :bees or :ALL export set is requested...
sub baz :Export(:bees) {
print "baassss!";
}
# Always export &qux
# (no matter what else is explicitly or implicitly requested)
sub qux :Export(:MANDATORY) {
print "quuuuuuuuux!";
}
IMPORT {
# This block is called when the module is used (as usual),
# but it is called after any export requests have been handled.
# Those requests will have been stripped from its @_ argument list
}
Implements a Perl 5 native version of what the Perl 6 symbol export mechanism will look like.
Its very straightforward:
- If you want a subroutine to be capable of being exported (when explicitly requested in the use arguments), you mark it with the :Export attribute.
- If you want a subroutine to be automatically exported when the module is used (without specific overriding arguments), you mark it with the :Export(:DEFAULT) attribute.
- If you want a subroutine to be automatically exported when the module is used (even if the user specifies overriding arguments), you mark it with the :Export(:MANDATORY) attribute.
- If the subroutine should also be exported when particular export groups are requested, you add the names of those export groups to the attributes argument list.

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.

CORBA::IDLtree is a Perl module that builds abstract syntax trees from CORBA IDL.

The main export is sub Parse_File which takes an IDL input file name as the parameter, and returns a reference to an array of references to the root nodes constructed (or 0 if there were syntax errors.)

Parse_File uses two auxiliary data structures:

@include_path - Paths where to look for included IDL files
%defines - Symbol definitions for the preprocessor
(cf. the -D switch on many C compilers)
where -DSYM=VAL is represented as
$defines{SYM} = VAL. -DSYM is represented as
$defines{SYM} = 1.

A further export is the sub Dump_Symbols which takes the return value
of Parse_File as the parameter, and prints the trees constructed to
stdout in IDL syntax.

Some would call TreeLine an Outliner, others would call it a PIM. TreeLine just stores almost any kind of information.
A tree structure makes it easy to keep things organized. And each node in the tree can contain several fields, forming a mini-database.
The output format for each node can be defined, and the output can be shown on the screen, printed, or exported to html.
Main features:
- Stores almost any type of information, including plain text, HTML, numbers, dates, times, booleans, URLs, etc.
- The tree structure helps keep things organized.
- Each node can have several fields that form a mini-database.
- Several node types, with different sets of fields, can be included in one file.
- The node format, including fields, output lines and tree-view icon, can be defined for each node type.
- The right-hand view can show one of three views - for showing output, editing node data and editing node titles.
- Clicking on URL fields in the output view opens the link in an external web browser.
- There are internal link fields that select another node based on a reference or a keyword.
- An executable link can run an external program or open a file when clicked.
- Formatting information can be copied from another TreeLine file.
- There are two search commands available.
- Undo and redo commands are available for all modifying operations.
- The formatted output can be printed with parent/child lines and headers and footers.
- TreeLine files are XML by default, but there are options for automatically compressing or encrypting the files.
- The data can be exported to HTML.
- An XSLT file can be exported to work with the XML TreeLine files.
- Tab-delimited tables and tab-indented text files can be imported and exported. Plain text files and Treepad files can be imported.
- Mozilla and XBEL format bookmark files can be imported and exported.
- Generic XML files can be imported and exported, allowing TreeLine to function as a crude XML editor.
- Batch file conversions can be done from a command line interface.
- There are several sorting options.
- The nodes can be filtered.
- Text data can be spell checked (requires an external program - see the System Requirements section).
- Data can be automatically arranged using either parent references or categories from data fields.
- There is an outline numbering feature.
- There are many other options for customization, including user-defined keyboard shortcuts.
- The user interface and documentation are available in English, French and German.

Log::Report::Lexicon::PO is a Perl module with one translation definition.

METHODS

Constructors

Log::Report::Lexicon::PO->new(OPTIONS)

Option --Default
automatic ""
comment []
format []
fuzzy false
msgid
msgid_plural undef
msgstr "" or []
references []
. automatic => PARAGRAPH

Automaticly added comments. See addAutomatic().

. comment => PARAGRAPH

Translator added comments. See addComment().

. format => ARRAY-OF-PAIRS|HASH

See format().

. fuzzy => BOOLEAN

The string is not yet translated, some smart guesses may have been made. See fuzzy().

. msgid => STRING
. msgid_plural => STRING
. msgstr => STRING|ARRAY-OF-STRING

The translations for the msgid. When msgid_plural is defined, then an ARRAY must be provided.

. references => STRING|ARRAY-OF-LOCATIONS

The STRING is a blank separated list of LOCATIONS. LOCATIONs are of the form filename:linenumber, for instance lib/Foo.pm:42 See addReferences()

Attributes

$obj->addAutomatic(LIST|ARRAY|STRING)

Add multiple lines to the translators comment block. Returns an empty string if there are no comments.

$obj->addComment(LIST|ARRAY|STRING)

Add multiple lines to the translators comment block. Returns an empty string if there are no comments.

$obj->addFlags(STRING)

Parse a "flags" line.

$obj->addReferences(STRING|LIST|ARRAY)

The STRING is a blank separated list of LOCATIONS. The LIST and ARRAY contain separate LOCATIONs. A LOCATION is of the form filename:linenumber. Returns the internal HASH with references.

$obj->automatic([LIST|ARRAY|STRING])

Returns a STRING which contains the cleaned paragraph of automatically added comments. If an argument is specified, it will replace the current comment.

$obj->comment([LIST|ARRAY|STRING])

Returns a STRING which contains the cleaned paragraph of translators comment. If an argument is specified, it will replace the current comment.

$obj->format(LANGUAGE|PAIRS|ARRAY-OF-PAIRS|HASH)

When one LANGUAGE is specified, it looks whether a LANGUAGE-format or no-LANGUAGE-format is present in the line of FLAGS. This will return 1 (true) in the first case, 0 (false) in the second case. It will return undef (also false) in case that both are not present.

You can also specify PAIRS: the key is a language name, and the value is either 0, 1, or undef.

Example: use of format()

if($po->format(c)) ...
unless($po->format(perl-brace)) ...
if(defined $po->format(java)) ...

$po->format(java => 1); # results in java-format
$po->format(java => 0); # results in no-java-format
$po->format(java => undef); # results in
$obj->fuzzy([BOOLEAN])

Returns whether the translation needs human inspection.

$obj->isActive

Returns whether the translation has any references, or is the header.

$obj->msgid

Returns the actual msgid, which cannot be undef.

$obj->msgstr([INDEX, [STRING]])

With a STRING, a new translation will be set. Without STRING, a lookup will take place. When no plural is defined, use INDEX 0

$obj->plural([STRING])

Returns the actual msgid_plural, which can be undef.

$obj->references([STRING|LIST|ARRAY])

Returns an unsorted list of LOCATIONS. When options are specified, then those will be used to replace all currently defined references. Returns the unsorted LIST of references.

$obj->removeReferencesTo(FILENAME)

Remove all the references to the indicate FILENAME from the list. Returns the number of refs left.

Parsing

Log::Report::Lexicon::PO->fromText(STRING, [WHERE])

Parse the STRING into a new PO object. The WHERE string should explain the location of the STRING, to be used in error messages.

$obj->toString(OPTIONS)

Format the object into a multi-lined string.

Option --Default
nr_plurals undef
. nr_plurals => INTEGER

If the number of plurals is specified, then the plural translation list can be checked for the correct lenght. Otherwise, no smart behavior is attempted.

$obj->unused

The message-id has no references anymore and no translations.