Free xml based software for linux

XML::SAX::Base is a base Perl class with SAX Drivers and Filters.

SYNOPSIS

package MyFilter;
use XML::SAX::Base;
@ISA = (XML::SAX::Base);

This module has a very simple task - to be a base class for PerlSAX drivers and filters. Its default behaviour is to pass the input directly to the output unchanged. It can be useful to use this module as a base class so you dont have to, for example, implement the characters() callback.

The main advantages that it provides are easy dispatching of events the right way (ie it takes care for you of checking that the handler has implemented that method, or has defined an AUTOLOAD), and the guarantee that filters will pass along events that they arent implementing to handlers downstream that might nevertheless be interested in them.

WRITING SAX DRIVERS AND FILTERS

Writing SAX Filters is tremendously easy: all you need to do is inherit from this module, and define the events you want to handle. A more detailed explanation can be found at http://www.xml.com/pub/a/2001/10/10/sax-filters.html.
Writing Drivers is equally simple. The one thing you need to pay attention to is NOT to call events yourself (this applies to Filters as well). For instance:
package MyFilter;
use base qw(XML::SAX::Base);

sub start_element {
my $self = shift;
my $data = shift;
# do something
$self->{Handler}->start_element($data); # BAD
}

The above example works well as precisely that: an example. But it has several faults: 1) it doesnt test to see whether the handler defines start_element. Perhaps it doesnt want to see that event, in which case you shouldnt throw it (otherwise itll die). 2) it doesnt check ContentHandler and then Handler (ie it doesnt look to see that the user hasnt requested events on a specific handler, and if not on the default one), 3) if it did check all that, not only would the code be cumbersome (see this modules source to get an idea) but it would also probably have to check for a DocumentHandler (in case this were SAX1) and for AUTOLOADs potentially defined in all these packages. As you can tell, that would be fairly painful. Instead of going through that, simply remember to use code similar to the following instead:

package MyFilter;
use base qw(XML::SAX::Base);

sub start_element {
my $self = shift;
my $data = shift;
# do something to filter
$self->SUPER::start_element($data); # GOOD (and easy) !
}

This way, once youve done your job you hand the ball back to XML::SAX::Base and it takes care of all those problems for you!

Note that the above example doesnt apply to filters only, drivers will benefit from the exact same feature.

XML::DOM::XML_Base Perl module can apply xml:base to attribute values.

SYNOPSIS

use XML::DOM::XML_Base;
my $parser = XML::DOM::Parser->new();

my $xml = qq(





);

# build the DOM
my $dom = $parser->parse( $xml );

# get some elements
my $endo = $dom->getElementsByTagName( endo )->item( 0 );
my $meso = $dom->getElementsByTagName( meso )->item( 0 );
my $ecto = $dom->getElementsByTagName( ecto )->item( 0 );

print $endo->getBase()."n"; # a/b/c/
print $meso->getBase()."n"; # a/b/
print $ecto->getBase()."n"; # a/

print $endo->getAttributeWithBase( x )."n"; # a/b/c/3
print $meso->getAttributeWithBase( x )."n"; # a/b/2
print $ecto->getAttributeWithBase( x )."n"; # a/1

Parsifal is a validating XML 1.0 parser written in ANSI C. Parsifal API is based on SAX2.
Parsifal can be used for parsing XML based messages (such as REST and RSS) and for application specific data processing e.g. config files, data files etc. Parsifal can also be used for document-oriented processing (e.g. XHTML xhtml1-transitional.dtd) and for parsing modular documents because it is conforming XML 1.0 parser and it supports features like internal and external general entities, DTD parameter entities and default attributes etc. Parsifal is ideal for processing large data files and streams since its SAX based and consumes very little memory not to mention it is fast enough for most purposes cos its written in C.
Using Parsifal in place of large XML processing libraries (e.g. libxml, xerces) or even in the place of small Expat (which doesnt support DTD validation) can be justified for limited memory environments and in applications requiring bundled parser; because of its modular design parsifal can be easily compiled to support DTD validation or to perform only non-validating parsing etc. If you need higher level tools, for example dom/xpath processing, you should look for other libs of course.
Main features:
- PublicID legal chars arent fully checked
- XML Namespaces 1.0 duplicate URIs arent checked
- Allows some illegal placement for parameter entity references (see conformance test results)
- Validation of TokenizedType attributes (e.g. ID) are not yet implemented nor checking for existence of valid NOTATIONs etc.
- Doesnt check non-determinism of content models in validating mode
Supported XML encodings
- UTF-8
- ISO-8859-1
- US-ASCII
When compiled with GNU libiconv support:
- UTF-16, UCS-2, UTF-32, UCS-4
- EUC-JP
- SHIFT_JIS
- ISO-8859-{1,2,3,4,5,7,9,10,13,14,15,16}
Enhancements:
- This release fixes GCC 4 issues and polishes the configuration script.

VTD-XML is a "non-extractive" XML processing software API implementing Virtual Token Descriptor. Currently, VTD-XML only supports built-in entity references (" &s ><<less