Free xml output software for linux

XmlAutoIndex (xai) is a module for Apache written in perl that browses your directories and outputs it into Xml.

The aim of this project is to replace mod_autoindex in Apache:
I would like to separate data from design, that is why I have made a xml output.

After that, using Xslt you can translate it into Html, Svg or Xul for example (you can make your own theme by updating xsl style sheet and with never touching the core engine).

Each plugins are indepentant and are here to generate thumbnails, previews, etc... Each previews, meta-data are cached in a cache directory to accelerate http queries. bonus: I have included in engine a handler that allows you to add comments per file, this behaviour does not require SQL server because comments are saved in files caches meta-data.

Mini-XML is a small XML parsing library that you can use to read XML and XML-like data files in your application without requiring large non-standard libraries. The project only requires an ANSI C compatible compiler (GCC works, as do most vendors ANSI C compilers) and a make program.
Main features:
- Reading of UTF-8 and UTF-16 and writing of UTF-8 encoded XML files and strings.
- Data is stored in a linked-list tree structure, preserving the XML data hierarchy.
- Supports arbitrary element names, attributes, and attribute values with no preset limits, just available memory.
- Supports integer, real, opaque ("cdata"), and text data types in "leaf" nodes.
- Functions for creating, indexing, and managing trees of data.
- "Find" and "walk" functions for easily locating and navigating trees of data.
Enhancements:
- This version adds a SAX API, more convenience functions, a user data pointer to the mxml_node_t structure, and improved HTML and new man page output from mxmldoc.
- This release also offers relaxed LGPL licensing that allows static linking.

MARC::XML is a subclass of MARC.pm to provide XML support.

SYNOPSIS

use MARC::XML;

#read in some MARC and output some XML
$myobject = MARC::XML->new("marc.mrc","usmarc");
$myobject->output({file=>">marc.xml",format=>"xml"});

#read in some XML and output some MARC
$myobject = MARC::XML->new("marc.xml","xml");
$myobject->output({file=>">marc.mrc","usmarc");

MARC::XML is a subclass of MARC.pm which provides methods for round-trip conversions between MARC and XML. MARC::XML requires that you have the CPAN modules MARC.pm and XML::Parser installed in your Perl library. Version 1.04 of MARC.pm and 2.27 of XML::Parser (or later) are required. As a subclass of MARC.pm a MARC::XML object will by default have the full functionality of a MARC.pm object. See the MARC.pm documentation for details.

The XML file that is read and generated by MARC::XML is not associated with a Document Type Definition (DTD). This means that your files need to be well-formed, but they will not be validated. When performing XML->MARC conversion it is important that the XML file is structured in a particular way. Fortunately, this is the same format that is generated by the MARC->XML conversion, so you should be able to be able to move your data easily between the two formats.

XML::DOM::Lite is a Lite Pure Perl XML DOM Parser Kit.

SYNOPSIS

# Parser
use XML::DOM::Lite qw(Parser :constants);

$parser = Parser->new( %options );
$doc = Parser->parse($xmlstr);
$doc = Parser->parseFile(/path/to/file.xml);

# strip whitespace (can be about 30% faster)
$doc = Parser->parse($xml, whitespace => strip);


# All Nodes
$copy = $node->cloneNode($deep);
$nodeType = $node->nodeType;
$parent = $node->parentNode;
$name = $node->nodeName;
$xmlstr = $node->xml;
$owner = $node->ownerDocument;

# Element Nodes
$first = $node->firstChild;
$last = $node->lastChild;
$tag = $node->tagName;
$prev = $node->nextSibling;
$next = $node->previousSibling;

$node->setAttribute("foo", $bar);
$foo = $node->getAttribute("foo");
foreach my $attr (@{$node->attributes}) { # attributes as nodelist
# ... do stuff
}
$node->attributes->{foo} = "bar"; # or as hashref (overload)

$liveNodeList = $node->getElementsByTagName("child"); # deep

$node->insertBefore($newchild, $refchild);
$node->replaceChild($newchild, $refchild);


# Text Nodes
$nodeValue = $node->nodeValue;
$node->nodeValue("new text value");

# Processing Instruction Nodes
# CDATA Nodes
# Comments
$data = $node->nodeValue;

# NodeList
$item = $nodeList->item(42);
$index = $nodeList->nodeIndex($node);
$nlist->insertNode($newNode, $index);
$removed = $nlist->removeNode($node);
$length = $nlist->length; # OR scalar(@$nodeList)


# NodeIterator and NodeFilter
use XML::DOM::Lite qw(NodeIterator :constants);

$niter = NodeIterator->new($rootnode, SHOW_ELEMENT, {
acceptNode => sub {
my $n = shift;
if ($n->tagName eq wantme) {
return FILTER_ACCEPT;
} elsif ($n->tagName eq skipme) {
return FILTER_SKIP;
} else {
return FILTER_REJECT;
}
}
);
while (my $n = $niter->nextNode) {
# do stuff
}

# XSLT
use XML::DOM::Lite qw(Parser XSLT);
$parser = Parser->new( whitespace => strip );
$xsldoc = $parser->parse($xsl);
$xmldoc = $parser->parse($xml);
$output = XSLT->process($xmldoc, $xsldoc);


# XPath
use XML::DOM::Lite qw(XPath);
$result = XPath->evaluate(/path/to/*[@attr="value"], $contextNode);


# Document
$rootnode = $doc->documentElement;
$nodeWithId = $doc->getElementById("my_node_id");
$textnode = $doc->createTextNode("some text string");
$element = $doc->createElement("myTagName");
$docfrag = $doc->createDocumentFragment();
$xmlstr = $doc->xml;
$nlist = $doc->selectNodes(/xpath/expression);
$node = $doc->selectSingleNode(/xpath/expression);


# Serializer
use XML::DOM::Lite qw(Serializer);

$serializer = Serializer->new;
$xmlout = $serializer->serializeToString($node);