Free parser generators software for linux

Sid is an LL(1) parser generator. This project can read grammars written in more convenient forms and transform them to LL(1).
The language-specific actions are stored seperately to the grammar, which allows for multiple languages in the future.
Although Sid is intended to be used with lexi an example is included demonstrating use with lex.
Enhancements:
- This is the first release of Sid as a stand-alone project. It has been moved out of the TenDRA compiler.

Exemplar is free software designed to make it easier to work with XML. Exemplar: An XML Parser Generator was started as a program to generate the smallest possible parser for a given vocabulary of XML. While it still retains the capability to do this, it is now a more general program intended to support conversion of specifications of XML vocabularies (DTDs, Schemas, etc) into useful code.
Main features:
- Input from DTD
- Output to Java (SAX versions 1.0 and 2.0)
- Output to XSLT
- Output to DTD
- Command line and Ant user interfaces
Benefits
Save Programmer Time
XML is supposed to be easy to parse, but its very easy to get wrong. Offload your programming efforts to Exemplar and you can spend more of your time working on the core functionality of your application.
Save Space
Working in a space constrained environment? Exemplar can create SAX-compatible parsers as small as 5kb. No more need to hand write XML parsers to make them fit your environment.
Free Software
Exemplar is distributed under a permissive, BSD-style license (OSI approved). This means that youll never have to worry about integrating Exemplar with your own work, whether its commercial or not.

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.

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.

SVG::Parser is a Perl module with XML Parser for SVG documents.

SYNOPSIS

#!/usr/bin/perl -w
use strict;
use SVG::Parser;

die "Usage: $0 n" unless @ARGV;

my $xml;
{
local $/=undef;
$xml=;
}

my $parser=new SVG::Parser(-debug => 1);
my $svg=$parser->parse($xml);
print $svg->xmlify;

and:

#!/usr/bin/perl -w
use strict;
use SVG::Parser qw(SAX=XML::LibXML::Parser::SAX Expat SAX);

die "Usage: $0 n" unless @ARGV;
my $svg=SVG::Parser->new()->parsefile($ARGV[0]);
print $svg->xmlify;

SVG::Parser is an XML parser for SVG Documents. It takes XML as input and produces an SVG object as its output.

SVG::Parser supports both XML::SAX and XML::Parser (Expat) parsers, with SAX preferred by default. Only one of these needs to be installed for SVG::Parser to function.

A list of preferred parsers may be specified in the import list - SVG::Parser will use the first parser that successfully loads. Some basic measures are taken to provide cross-compatability. Applications requiring more advanced parser features should use the relevant parser module directly; see SVG::Parser::Expat and SVG::Parser::SAX

Nmap Parser is a module that implements a interface to the information contained in an nmap scan. It is implemented by parsing the xml scan data that is generated by nmap.
This will enable anyone who utilizes nmap to quickly create fast and robust security scripts that utilize the powerful port scanning abilities of nmap.
Enhancements:
- Parsing of distance information was added. Ignoring of taskend, taskbegin, and taskprogress information was added.
- Tests for nmap 4.20 were added.
- The license was changed to the MIT-style.
- The "always null" bug for the service->protocol call was fixed.

XML::Parser::EasyTree is an easier tree style for XML::Parser.

SYNOPSIS

use XML::Parser;
use XML::Parser::EasyTree;
$XML::Parser::Easytree::Noempty=1;
my $p=new XML::Parser(Style=>EasyTree);
my $tree=$p->parsefile(something.xml);

XML::Parser::EasyTree adds a new "built-in" style called "EasyTree" to XML::Parser. Like XML::Parsers "Tree" style, setting this style causes the parser to build a lightweight tree structure representing the XML document. This structure is, at least in this authors opinion, easier to work with than the one created by the built-in style.
When the parser is invoked with the EasyTree style, it returns a reference to an array of tree nodes, each of which is a hash reference.

All nodes have a type key whose value is the type of the node: e for element nodes, t for text nodes, and p for processing instruction nodes. All nodes also have a content key whose value is a reference to an array holding the elements child nodes for element nodes, the string value for text nodes, and the data value for processing instruction nodes. Element nodes also have an attrib key whose value is a reference to a hash of attribute names and values. Processing instructions also have a target key whose value is the PIs target.

EasyTree nodes are ordinary Perl hashes and are not objects. Contiguous runs of text are always returned in a single node.

The reason the parser returns an array reference rather than the root elements node is that an XML document can legally contain processing instructions outside the root element (the xml-stylesheet PI is commonly used this way).

If the parsers Namespaces option is set, element and attribute names will be prefixed with their (possibly empty) namespace URI enclosed in curly brackets.

HTML::Parser is a HTML parser class. Objects of the HTML::Parser class will recognize markup and separate it from plain text (alias data content) in HTML documents. As different kinds of markup and text are recognized, the corresponding event handlers are invoked.
HTML::Parser is not a generic SGML parser.

We have tried to make it able to deal with the HTML that is actually "out there", and it normally parses as closely as possible to the way the popular web browsers do it instead of strictly following one of the many HTML specifications from W3C. Where there is disagreement, there is often an option that you can enable to get the official behaviour.

The document to be parsed may be supplied in arbitrary chunks. This makes on-the-fly parsing as documents are received from the network possible.
If event driven parsing does not feel right for your application, you might want to use HTML::PullParser. This is an HTML::Parser subclass that allows a more conventional program structure.

SYNOPSIS:

use HTML::Parser ();

# Create parser object
$p = HTML::Parser->new( api_version => 3,
start_h => [&start, "tagname, attr"],
end_h => [&end, "tagname"],
marked_sections => 1,
);

# Parse document text chunk by chunk
$p->parse($chunk1);
$p->parse($chunk2);
#...
$p->eof; # signal end of document

# Parse directly from file
$p->parse_file("foo.html");
# or
open(my $fh, "<<less