This module implements the URI class. Objects of this class represent
"Uniform Resource Identifier references" as specified in RFC 2396 (and
updated by RFC 2732).

URI objects can be used to access and manipulate the various
components that make up these strings. There are also methods to
combine URIs in various ways.

This module does one thing: Finds URIs and URLs in plain text. It finds
them quickly and it finds them all (or what URI::URL considers a URI to
be.) It only finds URIs which include a scheme (http:// or the like).

Author: Michael G Schwern with insight from
Uri Gutman, Greg Bacon, Jeff Pinyan, Roderick Schertler and others.

A patch to Perl 5.005_55 by the author implements a core API for weak
references. This module is a Perl-level interface to that API, allowing
weak references to be created in Perl.

A weak reference is just like an ordinary Perl reference except that it
isn't included in the reference count of the thing referred to. This
means that once all references to a particular piece of data are weak,
the piece of data is freed and all the weak references are set to
undef. This is particularly useful for implementing circular data
structures without memory leaks or caches of objects.

This module parses _/robots.txt_ files as specified in "A Standard for
Robot Exclusion", at Webmasters
can use the _/robots.txt_ file to forbid conforming robots from accessing
parts of their web site.

XML::Bare - A minimal XML parser that uses C to generate a folded perl
hash.

This package implements XML as the author thinks it should be, not as
the standard says. Means this parser is not XML conform. So be very
careful if you use this package, the result does not need to be the one
you would expect.

This module extends the XML::Parser module by Clark Cooper. The XML::Parser
module is built on top of XML::Parser::Expat, which is a lower level
interface to James Clark's expat library.

This module implements a Perl interface to the Gnome libxml2 library which
provides interfaces for parsing and manipulating XML files. This module allows
Perl programmers to make use of the highly capable validating XML parser and
the high performance DOM implementation.

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.