Free xml parser perl module software for linux

MyCMS perl module provides the MN::CMS Perl module used by the MyCMS.

MyCMS perl module contains Perl object classes to manage the data of MyCMS (such as articles, links, and images).

MN::CMS is a perl module that allows you to manage an Internet
publishing system.#

MyCMS is an extension module of MyNews.

MyCMS introduces the concept of article, author and moderator.

XML::Parser::PerlSAX is a Perl SAX parser using XML::Parser.

SYNOPSIS

use XML::Parser::PerlSAX;

$parser = XML::Parser::PerlSAX->new( [OPTIONS] );
$result = $parser->parse( [OPTIONS] );

$result = $parser->parse($string);

XML::Parser::PerlSAX is a PerlSAX parser using the XML::Parser module. This man page summarizes the specific options, handlers, and properties supported by XML::Parser::PerlSAX; please refer to the PerlSAX standard in `PerlSAX.pod for general usage information.

METHODS

new

Creates a new parser object. Default options for parsing, described below, are passed as key-value pairs or as a single hash. Options may be changed directly in the parser object unless stated otherwise. Options passed to `parse() override the default options in the parser object for the duration of the parse.

parse

Parses a document. Options, described below, are passed as key-value pairs or as a single hash. Options passed to `parse() override default options in the parser object.

location

Returns the location as a hash:

ColumnNumber The column number of the parse.
LineNumber The line number of the parse.
BytePosition The current byte position of the parse.
PublicId A string containing the public identifier, or undef
if none is available.
SystemId A string containing the system identifier, or undef
if none is available.
Base The current value of the base for resolving relative
URIs.

ALPHA WARNING: The `SystemId and `PublicId properties returned are the system and public identifiers of the document passed to `parse(), not the identifiers of the currently parsing external entity. The column, line, and byte positions are of the current entity being parsed.

XML::Parser is a perl module for parsing XML documents.

SYNOPSIS

use XML::Parser;

$p1 = new XML::Parser(Style => Debug);
$p1->parsefile(REC-xml-19980210.xml);
$p1->parse( Hello World );

# Alternative
$p2 = new XML::Parser(Handlers => {Start => &handle_start,
End => &handle_end,
Char => &handle_char});
$p2->parse($socket);

# Another alternative
$p3 = new XML::Parser(ErrorContext => 2);

$p3->setHandlers(Char => &text,
Default => &other);

open(FOO, xmlgenerator |);
$p3->parse(*FOO, ProtocolEncoding => ISO-8859-1);
close(FOO);

$p3->parsefile(junk.xml, ErrorContext => 3);

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 Clarks 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.

XML::RSS::Parser is a liberal object-oriented parser for RSS feeds.

SYNOPSIS

#!/usr/bin/perl -w
use strict;

use XML::RSS::Parser;
use FileHandle;

my $p = XML::RSS::Parser->new;
my $fh = FileHandle->new(/path/to/some/rss/file);
my $feed = $p->parse_file($fh);

# output some values
my $feed_title = $feed->query(/channel/title);
print $feed_title->text_content;
my $count = $feed->item_count;
print " ($count)n";
foreach my $i ( $feed->query(//item) ) {
my $node = $i->query(title);
print .$node->text_content;
print "n";
}

XML::RSS::Parser is a lightweight liberal parser of RSS feeds. This parser is "liberal" in that it does not demand compliance of a specific RSS version and will attempt to gracefully handle tags it does not expect or understand. The parsers only requirements is that the file is well-formed XML and remotely resembles RSS. Roughly speaking, well formed XML with a channel element as a direct sibling or the root tag and item elements etc.

There are a number of advantages to using this module then just using a standard parser-tree combination. There are a number of different RSS formats in use today. In very subtle ways these formats are not entirely compatible from one to another. XML::RSS::Parser makes a couple assumptions to "normalize" the parse tree into a more consistent form. For instance, it forces channel and item into a parent-child relationship. For more detail see "SPECIAL PROCESSING NOTES".

This module is leaner then XML::RSS -- the majority of code was for generating RSS files. It also provides a XPath-esque interface to the feeds tree.

While XML::RSS::Parser creates a normalized parse tree, it still leaves the mapping of overlapping and alternate tags common in the RSS format space to the developer. For this look at the XML::RAI (RSS Abstraction Interface) package which provides an object-oriented layer to XML::RSS::Parser trees that transparently maps these various tags to one common interface.

XML::RSS::Parser is based on XML::Elemental, a a SAX-based package for easily parsing XML documents into a more native and mostly object-oriented perl form.

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 );

Simple Plain Xml Parser (spxml) is a simple and plain xml parser written in C++. spxml supports pull-model and DOM-model xml parsing.
spxml is a stream-oriented parser. As the user passes it chunks of the input XML document, spxml identifies elements, character data or other entities and return the appropriate event. The size of the chunks is controlled by the user; chunks can range from one byte to the whole XML document.
spxml pull parser does not need to be told when the document is ended. On the contrary, spxml pull parser will tell us when it has finished parsing a root ( or other ) element. spxml pull parser can therefore safely read from pipes, can process sequences of XML documents without extra delimiters, and can handle selected parts of a document.
spxml DOM parser parses an XML document, and builds a DOM tree that can be read, modified, and saved.
Enhancements:
- This release adds UTF-8 encoding and processing instruction support.

PXR::Parser is a Pure Perl SAX XML Push Parser.

SYNOPSIS

use PXR::Parser;

my $parser = PXR::Parser->new(
Handlers => {
startDocument => &start_doc,
endDocument => &end_doc,
startElement => &start_element,
endElement => &end_element,
characters => &characters,
}
);

$parser->parse($data);

$parser->setHandlers(startDocument => &different_start);

A simple, fast, efficient pure perl sax xml parser.

BUGS AND NOTES

This Parser was blatantly ripped and modified from XML::Stream::Parser because it was the only pure perl parser simple and speedy enough to be included by default in various other things such as PXR or PoCo::Jabber. Just note that there is no recovering or detecting XML malformedness. So if you feed this little pet something non-tasty, you are in for a surprise (mainly memory leaking everywhere, and other things like gnawing on furniture).

That is the trade off for its speed. In situtations where you know you are not going to get malformed XML such as a connection to a jabber server (or other XML pushing entities) then this parser is ideal. Currently, the speed difference between this parser and XML::Parser::Expat are about 30 percent in favor of XML::Parser::Expat (which says alot of the speed of this pure perl implementation).

Thanks to Ryan Eatmon for writing and releasing this code. It has been a boon to those of us that really appreciate a simple small solution.

iCal::Parser::HTML is a Perl module to generate HTML calendars from iCalendars.

SYNOPSIS

use iCal::Parser::HTML;
my $parser=iCal::Parser::HTML->new;
print $parser->parse(type=>$type,start=>$date,files=>[@icals]);

This module uses iCal::Parser::SAX and XML::LibXSLT with included stylesheets to generates html calendars from icalendars.

The html document generated includes (when appropriate) a sidebar containing a legend, a list of todos and a three month calendar for the previous, current and next months.

The stylesheets are stored in the HTML/stylesheet directory under the installed package directory.

Also included in this package are an optionally installed command line program "ical2html" in scripts and, in the example directory, a cgi handler ("ical.cgi" in examples) and a stylesheet ("calendar.css" in examples) for formatting the html output. Note that the html output will look quite broken without the stylesheet.