Free xml libxml sax builder software for linux

XML::LibXML::Reader is a Perl interface to libxml2 pull parser.

SYNOPSIS

use XML::LibXML::Reader;

$reader = new XML::LibXML::Reader("file.xml")
or die "cannot read file.xmln";
while ($reader->read) {
processNode($reader);
}


sub processNode {
$reader = shift;
printf "%d %d %s %dn", ($reader->depth,
$reader->nodeType,
$reader->name,
$reader->isEmptyElement);
}
or
$reader = new XML::LibXML::Reader("file.xml")
or die "cannot read file.xmln";
$reader->preservePattern(//table/tr);
$reader->finish;
print $reader->document->toString(1);

This is a perl interface to libxml2s pull-parser implementation xmlTextReader http://xmlsoft.org/html/libxml-xmlreader.html. This feature requires at least libxml2-2.6.21. Pull-parser (StAX in Java, XmlReader in C#) use an iterator approach to parse a xml-file. They are easier to program than event-based parser (SAX) and much more lightweight than tree-based parser (DOM), which load the complete tree into memory.

The Reader acts as a cursor going forward on the document stream and stopping at each node in the way. At every point DOM-like methods of the Reader object allow to examine the current node (name, namespace, attributes, etc.)

The users code keeps control of the progress and simply calls the read() function repeatedly to progress to the next node in the document order. Other functions provide means for skipping complete sub-trees, or nodes until a specific element, etc.

At every time, only a very limited portion of the document is kept in the memory, which makes the API more memory-efficient than using DOM. However, it is also possible to mix Reader with DOM. At every point the user may copy the current node (optionally expanded into a complete sub-tree) from the processed document to another DOM tree, or to instruct the Reader to collect sub-document in form of a DOM tree consisting of selected nodes.

Reader API also supports namespaces, xml:base, entity handling, and DTD validation. Schema and RelaxNG validation support will probably be added in some later revision of the Perl interface.

The naming of methods compared to libxml2 and C# XmlTextReader has been changed slightly to match the conventions of XML::LibXML. Some functions have been changed or added with respect to the C interface.

XML::LibXML::Parser is a Perl module to parse XML Data with XML::LibXML.

SYNOPSIS

$parser = XML::LibXML->new();
$doc = $parser->parse_file( $xmlfilename );
$doc = $parser->parse_fh( $io_fh );
$doc = $parser->parse_string( $xmlstring);
$doc = $parser->parse_html_file( $htmlfile, %opts );
$doc = $parser->parse_html_fh( $io_fh, %opts );
$doc = $parser->parse_html_string( $htmlstring, %opts );
$fragment = $parser->parse_balanced_chunk( $wbxmlstring );
$fragment = $parser->parse_xml_chunk( $wbxmlstring );
$parser->process_xincludes( $doc );
$parser->processXIncludes( $doc );
$parser->parse_chunk($string, $terminate);
$parser->start_push();
$parser->push(@data);
$doc = $parser->finish_push( $recover );
$parser->validation(1);
$parser->recover(1);
$parser->recover_silently(1);
$parser->expand_entities(0);
$parser->keep_blanks(0);
$parser->pedantic_parser(1);
$parser->line_numbers(1);
$parser->load_ext_dtd(1);
$parser->complete_attributes(1);
$parser->expand_xinclude(1);
$parser->load_catalog( $catalog_file );
$parser->base_uri( $your_base_uri );
$parser->gdome_dom(1);
$parser->clean_namespaces( 1 );
$parser->no_network(1);

SYNOPSIS

use XML::LibXML;
my $parser = XML::LibXML->new();

my $doc = $parser->parse_string(parse_fh( $xmlstream );

my $fragment = $parser->parse_xml_chunk( $xml_wb_chunk );

XML::LibXML::DOM is a XML::LibXML DOM Implementation.

XML::LibXML provides an lightwight interface to modify a node of the document tree generated by the XML::LibXML parser. This interface follows as far as possible the DOM Level 3 specification. Additionally to the specified functions the XML::LibXML supports some functions that are more handy to use in the perl environment.

One also has to remember, that XML::LibXML is an interface to libxml2 nodes which actually reside on the C-Level of XML::LibXML. This means each node is a reference to a structure different than a perl hash or array. The only way to access these structures values is through the DOM interface provided by XML::LibXML. This also means, that one cant simply inherit a XML::LibXML node and add new member variables as they were hash keys.

The DOM interface of XML::LibXML does not intend to implement a full DOM interface as it is done by XML::GDOME and used for full featured application. Moreover, it offers an simple way to build or modify documents that are created by XML::LibXMLs parser.

Another target of the XML::LibXML interface is to make the interfaces of libxml2 available to the perl community. This includes also some workarounds to some features where libxml2 assumes more control over the C-Level that most perl users dont have.

One of the most important parts of the XML::LibXML DOM interface is, that the interfaces try do follow the DOM Level 3 specification rather strictly. This means the interface functions are named as the DOM specification says and not what widespread Java interfaces claim to be standard. Although there are several functions that have only a singular interface that conforms to the DOM spec XML::LibXML provides an additional Java style alias interface.

Also there are some function interfaces left over from early stages of XML::LibXML for compatibility reasons. These interfaces are for compatibility reasons only. They might disappear in one of the future versions of XML::LibXML, so a user is requested to switch over to the official functions.

More recent versions of perl (e.g. 5.6.1 or higher) support special flags to disinguish between UTF8 and so called binary data. XML::LibXML provides for these versions functionality to make efficient use of these flags: If a document has set an encoding other than UTF8 all strings that are not already in UTF8 are implicitly encoded from the document encoding to UTF8. On output these strings are commonly returned as UTF8 unless a user does request explicitly the original (aka. document) encoding.
Older version of perl (such as 5.00503 or less) do not support these flags. If XML::LibXML is build for these versions, all strings have to get encoded to UTF8 manualy before they are passed to any DOM functions.

NOTE: XML::LibXMLs magic encoding may not work on all plattforms. Some platforms are known to have a broken iconv(), which is partly used by libxml2. To test if your platform works correctly with your language encoding, build a simple document in the particular encoding and try to parse it with XML::LibXML. If your document gets parsed with out causing any segmentation faults, bus errors or whatever your OS throws. An example for such a test can be found in test 19encoding.t of the distribution.

Namespaces and XML::LibXMLs DOM implementation
XML::LibXMLs DOM implementation follows the DOM implementation of libxml2. This is important to know if namespaces are used. Namespaces cannot be declared on an document node. This is basicly because XPath doesnt know about document nodes. Therefore namespaces have to be declared on element nodes.

This can happen explicitly by using XML::LibXML:Elements setNamespace() function or more or less implicitly by using XML::LibXML::Documents createElementNS() or createAttributeNS() function. If the a namespace is not declared on the documentElement, the namespace will be localy declared for the newly created node. In case of Attributes this may look a bit confusing, since these nodes cannot have namespace declarations itself. In this case the namespace in internally applied to the attribute and later declared on the node the attribute is appended to.

Sax Filter is a modular set of filters that can be used to process XML documents via Javas SAX support.

Currently, the filters only process content (the ContentHandler interface).

XML::LibXML::XPathContext is an XPath evaluation.

SYNOPSIS

my $xpc = XML::LibXML::XPathContext->new();
my $xpc = XML::LibXML::XPathContext->new($node);
$xpc->registerNs($prefix, $namespace_uri)
$xpc->unregisterNs($prefix)
$uri = $xpc->lookupNs($prefix)
$xpc->registerVarLookupFunc($callback, $data)
$data = $xpc->getVarLookupData();
$callback = $xpc->getVarLookupFunc();
$xpc->unregisterVarLookupFunc($name);
$xpc->registerFunctionNS($name, $uri, $callback)
$xpc->unregisterFunctionNS($name, $uri)
$xpc->registerFunction($name, $callback)
$xpc->unregisterFunction($name)
@nodes = $xpc->findnodes($xpath)
@nodes = $xpc->findnodes($xpath, $context_node )
$nodelist = $xpc->findnodes($xpath, $context_node )
$object = $xpc->find($xpath )
$object = $xpc->find($xpath, $context_node )
$value = $xpc->findvalue($xpath )
$value = $xpc->findvalue($xpath, $context_node )
$xpc->setContextNode($node)
my $node = $xpc->getContextNode;
$xpc->setContextPosition($position)
my $position = $xpc->getContextPosition;
$xpc->setContextSize($size)
my $size = $xpc->getContextSize;
$xpc->setContextNode($node)

The XML::LibXML::XPathContext class provides an almost complete interface to libxml2s XPath implementation. With XML::LibXML::XPathContext is is possible to evaluate XPath expressions in the context of arbitrary node, context size, and context position, with a user-defined namespace-prefix mapping, custom XPath functions written in Perl, and even a custom XPath variable resolver.

XML::SAX::Writer is a Perl module with SAX2 Writer.

SYNOPSIS

use XML::SAX::Writer;
use XML::SAX::SomeDriver;

my $w = XML::SAX::Writer->new;
my $d = XML::SAX::SomeDriver->new(Handler => $w);

$d->parse(some options...);

Why yet another XML Writer ?

A new XML Writer was needed to match the SAX2 effort because quite naturally no existing writer understood SAX2. My first intention had been to start patching XML::Handler::YAWriter as it had previously been my favourite writer in the SAX1 world.

However the more I patched it the more I realised that what I thought was going to be a simple patch (mostly adding a few event handlers and changing the attribute syntax) was turning out to be a rewrite due to various ideas Id been collecting along the way. Besides, I couldnt find a way to elegantly make it work with SAX2 without breaking the SAX1 compatibility which people are probably still using. There are of course ways to do that, but most require user interaction which is something I wanted to avoid.

So in the end there was a new writer. I think its in fact better this way as it helps keep SAX1 and SAX2 separated.

XML::SAX2Perl is a Perl module to translate Perl SAX methods to Java/CORBA style methods.

SYNOPSIS

use XML::Perl2SAX;

$perl2sax = XML::Perl2SAX(handler => $java_style_handler);

XML::Perl2SAX is a SAX filter that translates Perl style SAX methods to Java/CORBA style method calls. This module performs the inverse operation from XML::SAX2Perl.

Perl2SAX is a Perl SAX document handler. The `new method takes a `handler argument that is a Java/CORBA style handler that the new Perl2SAX instance will call. The SAX interfaces are defined at < http://www.megginson.com/SAX/ >.