Free file parser software for linux

RDF::Simple::Parser is a simple RDF/XML parser that reads a string containing RDF in XML.

SYNOPSIS

my $uri = http://www.zooleika.org.uk/bio/foaf.rdf;
my $rdf = LWP::Simple::get($uri);

my $parser = RDF::Simple::Parser->new(base => $uri)
my @triples = $parser->parse_rdf($rdf);

# returns an array of array references which are triples

MIME::Parser is a experimental class for parsing MIME streams.

SYNOPSIS

Before reading further, you should see MIME::Tools to make sure that you understand where this module fits into the grand scheme of things. Go on, do it now. Ill wait.
Ready? Ok...

Basic usage examples

### Create a new parser object:
my $parser = new MIME::Parser;

### Tell it where to put things:
$parser->output_under("/tmp");

### Parse an input filehandle:
$entity = $parser->parse(*STDIN);

### Congratulations: you now have a (possibly multipart) MIME entity!
$entity->dump_skeleton; # for debugging

Examples of input

### Parse from filehandles:
$entity = $parser->parse(*STDIN);
$entity = $parser->parse(IO::File->new("some command|");

### Parse from any object that supports getline() and read():
$entity = $parser->parse($myHandle);

### Parse an in-core MIME message:
$entity = $parser->parse_data($message);

### Parse an MIME message in a file:
$entity = $parser->parse_open("/some/file.msg");

### Parse an MIME message out of a pipeline:
$entity = $parser->parse_open("gunzip - < file.msg.gz |");

### Parse already-split input (as "deliver" would give it to you):
$entity = $parser->parse_two("msg.head", "msg.body");

Examples of output control

### Keep parsed message bodies in core (default outputs to disk):
$parser->output_to_core(1);

### Output each message body to a one-per-message directory:
$parser->output_under("/tmp");

### Output each message body to the same directory:
$parser->output_dir("/tmp");

### Change how nameless message-component files are named:
$parser->output_prefix("msg");

Examples of error recovery

### Normal mechanism:
eval { $entity = $parser->parse(*STDIN) };
if ($@) {
$results = $parser->results;
$decapitated = $parser->last_head; ### get last top-level head
}

### Ultra-tolerant mechanism:
$parser->ignore_errors(1);
$entity = eval { $parser->parse(*STDIN) };
$error = ($@ || $parser->last_error);

### Cleanup all files created by the parse:
eval { $entity = $parser->parse(*STDIN) };
...
$parser->filer->purge;

Examples of parser options

### Automatically attempt to RFC-1522-decode the MIME headers?
$parser->decode_headers(1); ### default is false

### Parse contained "message/rfc822" objects as nested MIME streams?
$parser->extract_nested_messages(0); ### default is true

### Look for uuencode in "text" messages, and extract it?
$parser->extract_uuencode(1); ### default is false

### Should we forgive normally-fatal errors?
$parser->ignore_errors(0); ### default is true
Miscellaneous examples
### Convert a Mail::Internet object to a MIME::Entity:
@lines = (@{$mail->header}, "n", @{$mail->body});
$entity = $parser->parse_data(@lines);

PandaLex is the PDF parsing code from Panda, which has been split into its own project to increase its utility.

It is a flex and bison description of the PDF specification, which allows programmers to define callbacks to handle different document elements.

Simple Plain Xml Parser (spxml) is a simple and plain xml parser written in C++. spxml supports pull-model and DOM-model xml parsing.
spxml is a stream-oriented parser. As the user passes it chunks of the input XML document, spxml identifies elements, character data or other entities and return the appropriate event. The size of the chunks is controlled by the user; chunks can range from one byte to the whole XML document.
spxml pull parser does not need to be told when the document is ended. On the contrary, spxml pull parser will tell us when it has finished parsing a root ( or other ) element. spxml pull parser can therefore safely read from pipes, can process sequences of XML documents without extra delimiters, and can handle selected parts of a document.
spxml DOM parser parses an XML document, and builds a DOM tree that can be read, modified, and saved.
Enhancements:
- This release adds UTF-8 encoding and processing instruction support.

XML::Parser is a perl module for parsing XML documents.

SYNOPSIS

use XML::Parser;

$p1 = new XML::Parser(Style => Debug);
$p1->parsefile(REC-xml-19980210.xml);
$p1->parse( Hello World );

# Alternative
$p2 = new XML::Parser(Handlers => {Start => &handle_start,
End => &handle_end,
Char => &handle_char});
$p2->parse($socket);

# Another alternative
$p3 = new XML::Parser(ErrorContext => 2);

$p3->setHandlers(Char => &text,
Default => &other);

open(FOO, xmlgenerator |);
$p3->parse(*FOO, ProtocolEncoding => ISO-8859-1);
close(FOO);

$p3->parsefile(junk.xml, ErrorContext => 3);

This module provides ways to parse XML documents. It is built on top of XML::Parser::Expat, which is a lower level interface to James Clarks expat library. Each call to one of the parsing methods creates a new instance of XML::Parser::Expat which is then used to parse the document.

Expat options may be provided when the XML::Parser object is created. These options are then passed on to the Expat object on each parse call. They can also be given as extra arguments to the parse methods, in which case they override options given at XML::Parser creation time.

The behavior of the parser is controlled either by "Style" and/or "Handlers" options, or by "setHandlers" method. These all provide mechanisms for XML::Parser to set the handlers needed by XML::Parser::Expat. If neither Style nor Handlers are specified, then parsing just checks the document for being well-formed.

When underlying handlers get called, they receive as their first parameter the Expat object, not the Parser object.

Test::Parser is a collection of parsers for different test output file formats.
These parse the data into a general purpose data structure that can then be used to create reports, do post-processing analysis, etc.
Test::Parser can also export tests in SpikeSources TRPI test description XML language.
Installation:
To install the script and man pages in the standard areas, give the sequence of commands
$ perl Makefile.PL
$ make
$ make test
$ make install # you probably need to do this step as superuser
If you want to install the script in your own private space, use
$ perl Makefile.PL PREFIX=/home/joeuser
INSTALLMAN1DIR=/home/joeuser/man/man1
INSTALLMAN3DIR=/home/joeuser/man/man3
$ make
$ make test
$ make install # can do this step as joeuser
Note that `make test` does nothing interesting.
Enhancements:
- This release improves the LTP parser and adds a parse_ltp script that prints a tabular summary of the PASS/FAILs of test cases.

DKP Log Parser (DKPLP) is a tool designed to help administrate time-based and/or event-based DKP reward system in conjunction with EQDKP (or any other DKP software implementing a required interface). The project is configurable to be compatible with any game that produces any kind of log. There are currently predefined pattern sets for EverQuest, EverQuest2 and World of Warcraft (with CT RaidTracker). If you are playing another game then you can either write new patterns for it yourself, or ask the the forum (be sure to include a sample log though).
DKP Log Parsers goal is to reduce the administrative overhead of running complex DKP reward system, by parsing the logs, calculating the DKP per person and sending the results (the loot, raids, participants and DKP) directly to EQDKP (or other DKP software). Its widely configurable, allowing it to be used by the many variations of zero-sum and time-based DKP around.
Overview of how DKP Log Parser is used
DKP Log Parser is a software program run on a users desktop (Windows or Unix). It reads in the contents of a game log once a raid has been completed, parses all the information and displays the data for administrators to edit. Once happy with the information, the administrator uploads the data from their PC to the DKP Log Parser plugin on an EQDKP webserver (or any other server implementing the required DKPLP interface), where it can be viewed by all members of the DKP system.
Main features:
- Inbuilt support for Everquest, Everquest II, World of Warcrafts CT RaidTracker plugin, and Ventrilo.
- Extensible enough to be able to handle most logs.
- Time based dkp:
- Accrue DKP by minute, by interval, by event or by a combination of these.
- Zero-sum DKP can be enabled (by minute or by interval) or disabled.
- Tag certain intervals as being more or less important by using weightings to adjust the DKP.
- Data export:
- Upload data to for example EQDKP, select from a number of different data representations.
- Export to plain text
- Export to BB forum markup
- Export to wiki markup
- Export to XML
- Member list and alt character list synchronises with server, making it easy to share setups with other users.
- Optional autocompletion database to remember item names and values between sessions.
- Preprocessors available to perform other operations on the log file. The skys the limit!