XML::Parser::Lite - Lightweight pure-perl XML Parser (based on regexps)
use XML::Parser::Lite;
$p1 = new XML::Parser::Lite;
$p1->setHandlers(
Start => sub { shift; print "start: @_\n" },
Char => sub { shift; print "char: @_\n" },
End => sub { shift; print "end: @_\n" },
);
$p1->parse('<foo id="me">Hello World!</foo>');
$p2 = new XML::Parser::Lite
Handlers => {
Start => sub { shift; print "start: @_\n" },
Char => sub { shift; print "char: @_\n" },
End => sub { shift; print "end: @_\n" },
}
;
$p2->parse('<foo id="me">Hello <bar>cruel</bar> World!</foo>');
This module implements an XML parser with a interface similar to
the XML::Parser manpage. Though not all callbacks are supported, you should be able to
use it in the same way you use XML::Parser. Due to using experimental regexp
features it'll work only on Perl 5.6 and above and may behave differently on
different platforms.
Note that you cannot use regular expressions or split in callbacks. This is
due to a limitation of perl's regular expression implementation (which is
not re-entrant).
Constructor.
The new() method returns the object called on when called as object method.
This behaviour was inherited from the SOAP::Lite manpage,
which XML::Parser::Lite was split out from.
This means that the following effectively is
a no-op if $obj is a object:
$obj = $obj->new();
New accepts a single named parameter, Handlers with a hash ref as value:
my $parser = XML::Parser::Lite->new(
Handlers => {
Start => sub { shift; print "start: @_\n" },
Char => sub { shift; print "char: @_\n" },
End => sub { shift; print "end: @_\n" },
}
);
The handlers given will be passed to setHandlers.
Sets (or resets) the parsing handlers. Accepts a hash with the handler names
and handler code references as parameters. Passing undef instead of a
code reference replaces the handler by a no-op.
The following handlers can be set:
Init
Start
Char
End
Final
All other handlers are ignored.
Calling setHandlers without parameters resets all handlers to no-ops.
Parses the XML given. In contrast to XML::Parser's parse
method, parse() only parses strings.
Called before parsing starts. You should perform any necessary initializations
in Init.
Called at the start of each XML node. See the XML::Parser manpage for details.
Called for each character sequence. May be called multiple times for the
characters contained in an XML node (even for every single character).
Your implementation has to make sure that it captures all characters.
Called at the end of each XML node. See the XML::Parser manpage for details
See the XML::Parser manpage for details
See the XML::Parser manpage for details
See the XML::Parser manpage for details
Called at the end of the parsing process. You should perform any necessary
cleanup here.
the XML::Parser manpage - a full-blown XML Parser, on which XML::Parser::Lite is based.
Requires a C compiler and the expat XML parser.
the XML::Parser::LiteCopy manpage - a fork in the XML::Parser::Lite::Tree manpage.
YAX - another pure-perl module for XML parsing.
the XML::Parser::REX manpage - another module that parses XML with regular expressions.
Copyright (C) 2000-2007 Paul Kulchenko. All rights reserved.
Copyright (C) 2008 Martin Kutter. All rights reserved.
Copyright (C) 2013-2015 Fred Moyer. All rights reserved.
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself.
This parser is based on ``shallow parser''
http://www.cs.sfu.ca/~cameron/REX.html
Copyright (c) 1998, Robert D. Cameron.
Paul Kulchenko (paulclinger@yahoo.com)
Martin Kutter (martin.kutter@fen-net.de)
Fred Moyer (fred@redhotpenguin.com)
Additional handlers supplied by Adam Leggett.
David Steinbrunner (dsteinbrunner@pobox.com)
Neil Bowers (neil@bowers.com)
Paul Cochrane (paul@liekut.de)
|