This module is a fast XSLT library, based on the GNOME libxslt engine
that you can find at http://www.xmlsoft.org/XSLT/.

The performance is currently about twice that of XML::Sablotron (based
on XSLTMark tests converted to Perl). The libxslt processor is also
highly standard compliant, with practically all of XSLT 1.0 being
supported in version 0.9 of libxslt.

This module offers a simple way to process namespaced XML names
(unames) from within any application that may need them. It also helps
maintain a prefix to namespace URI map, and provides a number of basic
checks.

XML::NodeFilter is a generic node filter class for DOM traversal as
specified in the DOM Level 2 Traversal and Range specification. It
extends that specification, so this class is easier to use for Perl
programmers.

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 Clark's 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.

You will find examples in
/usr/share/doc/packages/perl-XML-Parser/samples. For documentation
read the XML::Parser and XML::Parser::Expat man pages.

This package contains regular expressions for the following XML tokens:
BaseChar, Ideographic, Letter, Digit, Extender, CombiningChar,
NameChar, EntityRef, CharRef, Reference, Name, NmToken, and AttValue.

XML::SAX consists of several framework classes for using and building
Perl SAX2 XML parsers, filters, and drivers. It is designed around the
need to be able to "plug in" different SAX parsers to an application
without requiring programmer intervention. Those of you familiar with
the DBI will be right at home. Some of the designs come from the Java
JAXP specification (SAX part), only without the javaness.

This module has a very simple task - to be a base class for PerlSAX drivers
and filters. It's 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 don't 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 aren't implementing to
handlers downstream that might nevertheless be interested in them.

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 I`d been collecting along the way.
Besides, I couldn`t 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 it`s in fact better this way as it
helps keep SAX1 and SAX2 separated.

Author: Robin Berjon

XML::Simple - Easy API to read/write XML (esp config files)

This module provides the user with methods to connect to a remote server,
send a stream of XML to the server, and receive/parse an XML stream from
the server. It is primarily based work for the Etherx XML router
developed by the Jabber Development Team. For more information about this
project visit http://xmpp.org/protocols/streams/.

XML::Twig is (yet another!) XML transformation module.

Its strong points: can be used to process huge documents while still
being in tree mode; not bound by DOM or SAX, so it is very perlish and
offers a very comprehensive set of methods; simple to use; DWIMs as
much as possible

What it doesn't offer: full SAX support (it can export SAX, but only
reads XML), full XPath support (unless you use XML::Twig::XPath), nor
DOM support.

Other drawbacks: it is a big module, and with over 500 methods
available it can be a bit overwhelming. A good starting point is the
tutorial at http://xmltwig.com/xmltwig/tutorial/index.html. In fact the
whole XML::Twig page at http://xmltwig.com/xmltwig/ has plenty of
information to get you started with XML::Twig

XML::Writer is a helper module for Perl programs that write an XML
document. The module handles all escaping for attribute values and
character data and constructs different types of markup, such as tags,
comments, and processing instructions.

This module provides an XPath engine, that can be re-used by other
module/classes that implement trees.

This is a Perl module to parse XSL Transformational sheets.

A Go board, sgf editor and client for IGS/NNGS/WINGS based on the Qt
library. Go is an ancient boardgame, very common in Japan, China and
Korea.

The quota subsystem allows a system administrator to set soft and hard
limits on used space and the number of inodes used for users and
groups. The kernel must be compiled with disk quota support enabled
(SUSE kernels have this support).

A tool to log and analyze data gathered from all kinds of data sources.
The data analysis part of RRDtool is based on the ability to quickly
generate graphical representations of the data values collected over a
definable time period.

Setserial is a basic system utility for displaying or setting serial
port information. Setserial can reveal and allow you to alter the I/O
port and IRQ that a particular serial device is using.

Statserial displays a table of the signals on a standard 9-pin or
25-pin serial port and indicates the status of the handshaking lines.
It can be useful for debugging problems with serial ports or modems.

Telnet is an old protocol for logging into remote systems. It is
rarely used, since the transfer is not encrypted (ssh is mostly used
these days). The telnet client is often used for debugging other
network services. The command

telnet localhost 25

connects to the local smtp server, for example.

Tidy is a commandline frontend to TidyLib which allows for cleaning up and
pretty printing HTML, XHTML and XML markup in a variety of file encodings. For
HTML variants, it can detect and report proprietary elements as well as many
common coding errors, correct them and produce visually equivalent markup
which is both compliant with W3C standards and works on most browsers.
Furthermore, it can convert plain HTML to XHTML. For generic XML files, Tidy is
limited to correcting basic well-formedness errors and pretty printing.

tolua++ is an extended version of tolua, a tool to integrate C/C++ code with
Lua. tolua++ includes new features oriented to c++ such as:
* support for std::string as a basic type (this can be turned off by a command
line option)
* support for class templates
as well as other features and bugfixes.

Webalizer is a web server log file analysis program which produces
usage statistics in HTML format for viewing with a browser. The
results are presented in both columnar and graphical formats, which
facilitates interpretation. Yearly, monthly, daily, and hourly usage
statistics are presented, along with the ability to display usage by
site, URL, referrer, user agent (browser) and country (user agent and
referrer are only available if your web server produces Combined log
format files).

Webalizer supports CLF (common log format) log files, as well as
Combined log formats as defined by NCSA and others, and variations of
these which it attempts to handle intelligently.

A PPP dialer. With this program you can manually establish a PPP
connection to your ISP. Manual configuration, like dealing with chat
scripts, is normally not necessary as this program contains enough
intelligence to deal with most ISPs.

YTalk is, in essence, a multiuser chat program. It works almost exactly
like the UNIX talk program and even communicates with the same talk
daemons, but YTalk allows for multiple connections.