ÿØÿà JFIF    ÿÛ „ ( %!1!%*+...983,7(-.- PKM]w2gFgFLibXML/Reader.podnu6$=head1 NAME XML::LibXML::Reader - XML::LibXML::Reader - interface to libxml2 pull parser =head1 SYNOPSIS use XML::LibXML::Reader; my $reader = XML::LibXML::Reader->new(location => "file.xml") or die "cannot read file.xml\n"; while ($reader->read) { processNode($reader); } sub processNode { my $reader = shift; printf "%d %d %s %d\n", ($reader->depth, $reader->nodeType, $reader->name, $reader->isEmptyElement); } or my $reader = XML::LibXML::Reader->new(location => "file.xml") or die "cannot read file.xml\n"; $reader->preservePattern('//table/tr'); $reader->finish; print $reader->document->toString(1); =head1 DESCRIPTION This is a perl interface to libxml2's pull-parser implementation xmlTextReader I<<<<<< http://xmlsoft.org/html/libxml-xmlreader.html >>>>>>. This feature requires at least libxml2-2.6.21. Pull-parsers (such as StAX in Java, or XmlReader in C#) use an iterator approach to parse XML documents. They are easier to program than event-based parser (SAX) and much more lightweight than tree-based parser (DOM), which load the complete tree into memory. The Reader acts as a cursor going forward on the document stream and stopping at each node on the way. At every point, the DOM-like methods of the Reader object allow one to examine the current node (name, namespace, attributes, etc.) The user's code keeps control of the progress and simply calls the C<<<<<< read() >>>>>> function repeatedly to progress to the next node in the document order. Other functions provide means for skipping complete sub-trees, or nodes until a specific element, etc. At every time, only a very limited portion of the document is kept in the memory, which makes the API more memory-efficient than using DOM. However, it is also possible to mix Reader with DOM. At every point the user may copy the current node (optionally expanded into a complete sub-tree) from the processed document to another DOM tree, or to instruct the Reader to collect sub-document in form of a DOM tree consisting of selected nodes. Reader API also supports namespaces, xml:base, entity handling, and DTD validation. Schema and RelaxNG validation support will probably be added in some later revision of the Perl interface. The naming of methods compared to libxml2 and C# XmlTextReader has been changed slightly to match the conventions of XML::LibXML. Some functions have been changed or added with respect to the C interface. =head1 CONSTRUCTOR Depending on the XML source, the Reader object can be created with either of: my $reader = XML::LibXML::Reader->new( location => "file.xml", ... ); my $reader = XML::LibXML::Reader->new( string => $xml_string, ... ); my $reader = XML::LibXML::Reader->new( IO => $file_handle, ... ); my $reader = XML::LibXML::Reader->new( FD => fileno(STDIN), ... ); my $reader = XML::LibXML::Reader->new( DOM => $dom, ... ); where ... are (optional) reader options described below in L<<<<<< Reader options >>>>>> or various parser options described in L<<<<<< XML::LibXML::Parser >>>>>>. The constructor recognizes the following XML sources: =head2 Source specification =over 4 =item location Read XML from a local file or (non-HTTPS) URL. =item string Read XML from a string. =item IO Read XML a Perl IO filehandle. =item FD Read XML from a file descriptor (bypasses Perl I/O layer, only applicable to filehandles for regular files or pipes). Possibly faster than IO. =item DOM Use reader API to walk through a pre-parsed L<<<<<< XML::LibXML::Document >>>>>>. =back =head2 Reader options =over 4 =item encoding => $encoding override document encoding. =item RelaxNG => $rng_schema can be used to pass either a L<<<<<< XML::LibXML::RelaxNG >>>>>> object or a filename or (non-HTTPS) URL of a RelaxNG schema to the constructor. The schema is then used to validate the document as it is processed. =item Schema => $xsd_schema can be used to pass either a L<<<<<< XML::LibXML::Schema >>>>>> object or a filename or (non-HTTPS) URL of a W3C XSD schema to the constructor. The schema is then used to validate the document as it is processed. =item ... the reader further supports various parser options described in L<<<<<< XML::LibXML::Parser >>>>>> (specifically those labeled by /reader/). =back =head1 METHODS CONTROLLING PARSING PROGRESS =over 4 =item read () Moves the position to the next node in the stream, exposing its properties. Returns 1 if the node was read successfully, 0 if there is no more nodes to read, or -1 in case of error =item readAttributeValue () Parses an attribute value into one or more Text and EntityReference nodes. Returns 1 in case of success, 0 if the reader was not positioned on an attribute node or all the attribute values have been read, or -1 in case of error. =item readState () Gets the read state of the reader. Returns the state value, or -1 in case of error. The module exports constants for the Reader states, see STATES below. =item depth () The depth of the node in the tree, starts at 0 for the root node. =item next () Skip to the node following the current one in the document order while avoiding the sub-tree if any. Returns 1 if the node was read successfully, 0 if there is no more nodes to read, or -1 in case of error. =item nextElement (localname?,nsURI?) Skip nodes following the current one in the document order until a specific element is reached. The element's name must be equal to a given localname if defined, and its namespace must equal to a given nsURI if defined. Either of the arguments can be undefined (or omitted, in case of the latter or both). Returns 1 if the element was found, 0 if there is no more nodes to read, or -1 in case of error. =item nextPatternMatch (compiled_pattern) Skip nodes following the current one in the document order until an element matching a given compiled pattern is reached. See L<<<<<< XML::LibXML::Pattern >>>>>> for information on compiled patterns. See also the C<<<<<< matchesPattern >>>>>> method. Returns 1 if the element was found, 0 if there is no more nodes to read, or -1 in case of error. =item skipSiblings () Skip all nodes on the same or lower level until the first node on a higher level is reached. In particular, if the current node occurs in an element, the reader stops at the end tag of the parent element, otherwise it stops at a node immediately following the parent node. Returns 1 if successful, 0 if end of the document is reached, or -1 in case of error. =item nextSibling () It skips to the node following the current one in the document order while avoiding the sub-tree if any. Returns 1 if the node was read successfully, 0 if there is no more nodes to read, or -1 in case of error =item nextSiblingElement (name?,nsURI?) Like nextElement but only processes sibling elements of the current node (moving forward using C<<<<<< nextSibling () >>>>>> rather than C<<<<<< read () >>>>>>, internally). Returns 1 if the element was found, 0 if there is no more sibling nodes, or -1 in case of error. =item finish () Skip all remaining nodes in the document, reaching end of the document. Returns 1 if successful, 0 in case of error. =item close () This method releases any resources allocated by the current instance and closes any underlying input. It returns 0 on failure and 1 on success. This method is automatically called by the destructor when the reader is forgotten, therefore you do not have to call it directly. =back =head1 METHODS EXTRACTING INFORMATION =over 4 =item name () Returns the qualified name of the current node, equal to (Prefix:)LocalName. =item nodeType () Returns the type of the current node. See NODE TYPES below. =item localName () Returns the local name of the node. =item prefix () Returns the prefix of the namespace associated with the node. =item namespaceURI () Returns the URI defining the namespace associated with the node. =item isEmptyElement () Check if the current node is empty, this is a bit bizarre in the sense that will be considered empty while will not. =item hasValue () Returns true if the node can have a text value. =item value () Provides the text value of the node if present or undef if not available. =item readInnerXml () Reads the contents of the current node, including child nodes and markup. Returns a string containing the XML of the node's content, or undef if the current node is neither an element nor attribute, or has no child nodes. =item readOuterXml () Reads the contents of the current node, including child nodes and markup. Returns a string containing the XML of the node including its content, or undef if the current node is neither an element nor attribute. =item nodePath() Returns a canonical location path to the current element from the root node to the current node. Namespaced elements are matched by '*', because there is no way to declare prefixes within XPath patterns. Unlike C<<<<<< XML::LibXML::Node::nodePath() >>>>>>, this function does not provide sibling counts (i.e. instead of e.g. '/a/b[1]' and '/a/b[2]' you get '/a/b' for both matches). =item matchesPattern(compiled_pattern) Returns a true value if the current node matches a compiled pattern. See L<<<<<< XML::LibXML::Pattern >>>>>> for information on compiled patterns. See also the C<<<<<< nextPatternMatch >>>>>> method. =back =head1 METHODS EXTRACTING DOM NODES =over 4 =item document () Provides access to the document tree built by the reader. This function can be used to collect the preserved nodes (see C<<<<<< preserveNode() >>>>>> and preservePattern). CAUTION: Never use this function to modify the tree unless reading of the whole document is completed! =item copyCurrentNode (deep) This function is similar a DOM function C<<<<<< copyNode() >>>>>>. It returns a copy of the currently processed node as a corresponding DOM object. Use deep = 1 to obtain the full sub-tree. =item preserveNode () This tells the XML Reader to preserve the current node in the document tree. A document tree consisting of the preserved nodes and their content can be obtained using the method C<<<<<< document() >>>>>> once parsing is finished. Returns the node or NULL in case of error. =item preservePattern (pattern,\%ns_map) This tells the XML Reader to preserve all nodes matched by the pattern (which is a streaming XPath subset). A document tree consisting of the preserved nodes and their content can be obtained using the method C<<<<<< document() >>>>>> once parsing is finished. An optional second argument can be used to provide a HASH reference mapping prefixes used by the XPath to namespace URIs. The XPath subset available with this function is described at http://www.w3.org/TR/xmlschema-1/#Selector and matches the production Path ::= ('.//')? ( Step '/' )* ( Step | '@' NameTest ) Returns a positive number in case of success and -1 in case of error =back =head1 METHODS PROCESSING ATTRIBUTES =over 4 =item attributeCount () Provides the number of attributes of the current node. =item hasAttributes () Whether the node has attributes. =item getAttribute (name) Provides the value of the attribute with the specified qualified name. Returns a string containing the value of the specified attribute, or undef in case of error. =item getAttributeNs (localName, namespaceURI) Provides the value of the specified attribute. Returns a string containing the value of the specified attribute, or undef in case of error. =item getAttributeNo (no) Provides the value of the attribute with the specified index relative to the containing element. Returns a string containing the value of the specified attribute, or undef in case of error. =item isDefault () Returns true if the current attribute node was generated from the default value defined in the DTD. =item moveToAttribute (name) Moves the position to the attribute with the specified local name and namespace URI. Returns 1 in case of success, -1 in case of error, 0 if not found =item moveToAttributeNo (no) Moves the position to the attribute with the specified index relative to the containing element. Returns 1 in case of success, -1 in case of error, 0 if not found =item moveToAttributeNs (localName,namespaceURI) Moves the position to the attribute with the specified local name and namespace URI. Returns 1 in case of success, -1 in case of error, 0 if not found =item moveToFirstAttribute () Moves the position to the first attribute associated with the current node. Returns 1 in case of success, -1 in case of error, 0 if not found =item moveToNextAttribute () Moves the position to the next attribute associated with the current node. Returns 1 in case of success, -1 in case of error, 0 if not found =item moveToElement () Moves the position to the node that contains the current attribute node. Returns 1 in case of success, -1 in case of error, 0 if not moved =item isNamespaceDecl () Determine whether the current node is a namespace declaration rather than a regular attribute. Returns 1 if the current node is a namespace declaration, 0 if it is a regular attribute or other type of node, or -1 in case of error. =back =head1 OTHER METHODS =over 4 =item lookupNamespace (prefix) Resolves a namespace prefix in the scope of the current element. Returns a string containing the namespace URI to which the prefix maps or undef in case of error. =item encoding () Returns a string containing the encoding of the document or undef in case of error. =item standalone () Determine the standalone status of the document being read. Returns 1 if the document was declared to be standalone, 0 if it was declared to be not standalone, or -1 if the document did not specify its standalone status or in case of error. =item xmlVersion () Determine the XML version of the document being read. Returns a string containing the XML version of the document or undef in case of error. =item baseURI () Returns the base URI of a given node. =item isValid () Retrieve the validity status from the parser. Returns 1 if valid, 0 if no, and -1 in case of error. =item xmlLang () The xml:lang scope within which the node resides. =item lineNumber () Provide the line number of the current parsing point. =item columnNumber () Provide the column number of the current parsing point. =item byteConsumed () This function provides the current index of the parser relative to the start of the current entity. This function is computed in bytes from the beginning starting at zero and finishing at the size in bytes of the file if parsing a file. The function is of constant cost if the input is UTF-8 but can be costly if run on non-UTF-8 input. =item setParserProp (prop => value, ...) Change the parser processing behaviour by changing some of its internal properties. The following properties are available with this function: ``load_ext_dtd'', ``complete_attributes'', ``validation'', ``expand_entities''. Since some of the properties can only be changed before any read has been done, it is best to set the parsing properties at the constructor. Returns 0 if the call was successful, or -1 in case of error =item getParserProp (prop) Get value of an parser internal property. The following property names can be used: ``load_ext_dtd'', ``complete_attributes'', ``validation'', ``expand_entities''. Returns the value, usually 0 or 1, or -1 in case of error. =back =head1 DESTRUCTION XML::LibXML takes care of the reader object destruction when the last reference to the reader object goes out of scope. The document tree is preserved, though, if either of $reader->document or $reader->preserveNode was used and references to the document tree exist. =head1 NODE TYPES The reader interface provides the following constants for node types (the constant symbols are exported by default or if tag C<<<<<< :types >>>>>> is used). XML_READER_TYPE_NONE => 0 XML_READER_TYPE_ELEMENT => 1 XML_READER_TYPE_ATTRIBUTE => 2 XML_READER_TYPE_TEXT => 3 XML_READER_TYPE_CDATA => 4 XML_READER_TYPE_ENTITY_REFERENCE => 5 XML_READER_TYPE_ENTITY => 6 XML_READER_TYPE_PROCESSING_INSTRUCTION => 7 XML_READER_TYPE_COMMENT => 8 XML_READER_TYPE_DOCUMENT => 9 XML_READER_TYPE_DOCUMENT_TYPE => 10 XML_READER_TYPE_DOCUMENT_FRAGMENT => 11 XML_READER_TYPE_NOTATION => 12 XML_READER_TYPE_WHITESPACE => 13 XML_READER_TYPE_SIGNIFICANT_WHITESPACE => 14 XML_READER_TYPE_END_ELEMENT => 15 XML_READER_TYPE_END_ENTITY => 16 XML_READER_TYPE_XML_DECLARATION => 17 =head1 STATES The following constants represent the values returned by C<<<<<< readState() >>>>>>. They are exported by default, or if tag C<<<<<< :states >>>>>> is used: XML_READER_NONE => -1 XML_READER_START => 0 XML_READER_ELEMENT => 1 XML_READER_END => 2 XML_READER_EMPTY => 3 XML_READER_BACKTRACK => 4 XML_READER_DONE => 5 XML_READER_ERROR => 6 =head1 SEE ALSO L<<<<<< XML::LibXML::Pattern >>>>>> for information about compiled patterns. http://xmlsoft.org/html/libxml-xmlreader.html http://dotgnu.org/pnetlib-doc/System/Xml/XmlTextReader.html =head1 ORIGINAL IMPLEMENTATION Heiko Klein, and Petr Pajas =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM])V2%o%oLibXML/Parser.podnu6$=head1 NAME XML::LibXML::Parser - Parsing XML Data with XML::LibXML =head1 SYNOPSIS use XML::LibXML '1.70'; # Parser constructor $parser = XML::LibXML->new(); $parser = XML::LibXML->new(option=>value, ...); $parser = XML::LibXML->new({option=>value, ...}); # Parsing XML $dom = XML::LibXML->load_xml( location => $file_or_url # parser options ... ); $dom = XML::LibXML->load_xml( string => $xml_string # parser options ... ); $dom = XML::LibXML->load_xml( string => (\$xml_string) # parser options ... ); $dom = XML::LibXML->load_xml({ IO => $perl_file_handle # parser options ... ); $dom = $parser->load_xml(...); # Parsing HTML $dom = XML::LibXML->load_html(...); $dom = $parser->load_html(...); # Parsing well-balanced XML chunks $fragment = $parser->parse_balanced_chunk( $wbxmlstring, $encoding ); # Processing XInclude $parser->process_xincludes( $doc ); $parser->processXIncludes( $doc ); # Old-style parser interfaces $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 ); # Push parser $parser->parse_chunk($string, $terminate); $parser->init_push(); $parser->push(@data); $doc = $parser->finish_push( $recover ); # Set/query parser options $parser->option_exists($name); $parser->get_option($name); $parser->set_option($name,$value); $parser->set_options({$name=>$value,...}); # XML catalogs $parser->load_catalog( $catalog_file ); =head1 PARSING An XML document is read into a data structure such as a DOM tree by a piece of software, called a parser. XML::LibXML currently provides four different parser interfaces: =over 4 =item * A DOM Pull-Parser =item * A DOM Push-Parser =item * A SAX Parser =item * A DOM based SAX Parser. =back =head2 Creating a Parser Instance XML::LibXML provides an OO interface to the libxml2 parser functions. Thus you have to create a parser instance before you can parse any XML data. =over 4 =item new $parser = XML::LibXML->new(); $parser = XML::LibXML->new(option=>value, ...); $parser = XML::LibXML->new({option=>value, ...}); Create a new XML and HTML parser instance. Each parser instance holds default values for various parser options. Optionally, one can pass a hash reference or a list of option => value pairs to set a different default set of options. Unless specified otherwise, the options C<<<<<< load_ext_dtd >>>>>>, and C<<<<<< expand_entities >>>>>> are set to 1. See L<<<<<< Parser Options >>>>>> for a list of libxml2 parser's options. =back =head2 DOM Parser One of the common parser interfaces of XML::LibXML is the DOM parser. This parser reads XML data into a DOM like data structure, so each tag can get accessed and transformed. XML::LibXML's DOM parser is not only capable to parse XML data, but also (strict) HTML files. There are three ways to parse documents - as a string, as a Perl filehandle, or as a filename/URL. The return value from each is a L<<<<<< XML::LibXML::Document >>>>>> object, which is a DOM object. All of the functions listed below will throw an exception if the document is invalid. To prevent this causing your program exiting, wrap the call in an eval{} block =over 4 =item load_xml $dom = XML::LibXML->load_xml( location => $file_or_url # parser options ... ); $dom = XML::LibXML->load_xml( string => $xml_string # parser options ... ); $dom = XML::LibXML->load_xml( string => (\$xml_string) # parser options ... ); $dom = XML::LibXML->load_xml({ IO => $perl_file_handle # parser options ... ); $dom = $parser->load_xml(...); This function is available since XML::LibXML 1.70. It provides easy to use interface to the XML parser that parses given file (or non-HTTPS URL), string, or input stream to a DOM tree. The arguments can be passed in a HASH reference or as name => value pairs. The function can be called as a class method or an object method. In both cases it internally creates a new parser instance passing the specified parser options; if called as an object method, it clones the original parser (preserving its settings) and additionally applies the specified options to the new parser. See the constructor C<<<<<< new >>>>>> and L<<<<<< Parser Options >>>>>> for more information. Note that, due to a limitation in the underlying libxml2 library, this call does not recognize HTTPS-based URLs. (It will treat an HTTPS URL as a filename, likely throwing a "No such file or directory" exception.) =item load_html $dom = XML::LibXML->load_html(...); $dom = $parser->load_html(...); This function is available since XML::LibXML 1.70. It has the same usage as C<<<<<< load_xml >>>>>>, providing interface to the HTML parser. See C<<<<<< load_xml >>>>>> for more information. =back Parsing HTML may cause problems, especially if the ampersand ('&') is used. This is a common problem if HTML code is parsed that contains links to CGI-scripts. Such links cause the parser to throw errors. In such cases libxml2 still parses the entire document as there was no error, but the error causes XML::LibXML to stop the parsing process. However, the document is not lost. Such HTML documents should be parsed using the I<<<<<< recover >>>>>> flag. By default recovering is deactivated. The functions described above are implemented to parse well formed documents. In some cases a program gets well balanced XML instead of well formed documents (e.g. an XML fragment from a database). With XML::LibXML it is not required to wrap such fragments in the code, because XML::LibXML is capable even to parse well balanced XML fragments. =over 4 =item parse_balanced_chunk $fragment = $parser->parse_balanced_chunk( $wbxmlstring, $encoding ); This function parses a well balanced XML string into a L<<<<<< XML::LibXML::DocumentFragment >>>>>>. The first arguments contains the input string, the optional second argument can be used to specify character encoding of the input (UTF-8 is assumed by default). =item parse_xml_chunk This is the old name of parse_balanced_chunk(). Because it may causes confusion with the push parser interface, this function should not be used anymore. =back By default XML::LibXML does not process XInclude tags within an XML Document (see options section below). XML::LibXML allows one to post-process a document to expand XInclude tags. =over 4 =item process_xincludes $parser->process_xincludes( $doc ); After a document is parsed into a DOM structure, you may want to expand the documents XInclude tags. This function processes the given document structure and expands all XInclude tags (or throws an error) by using the flags and callbacks of the given parser instance. Note that the resulting Tree contains some extra nodes (of type XML_XINCLUDE_START and XML_XINCLUDE_END) after successfully processing the document. These nodes indicate where data was included into the original tree. if the document is serialized, these extra nodes will not show up. Remember: A Document with processed XIncludes differs from the original document after serialization, because the original XInclude tags will not get restored! If the parser flag "expand_xincludes" is set to 1, you need not to post process the parsed document. =item processXIncludes $parser->processXIncludes( $doc ); This is an alias to process_xincludes, but through a JAVA like function name. =item parse_file $doc = $parser->parse_file( $xmlfilename ); This function parses an XML document from a file or network; $xmlfilename can be either a filename or a (non-HTTPS) URL. Note that for parsing files, this function is the fastest choice, about 6-8 times faster then parse_fh(). =item parse_fh $doc = $parser->parse_fh( $io_fh ); parse_fh() parses a IOREF or a subclass of IO::Handle. Because the data comes from an open handle, libxml2's parser does not know about the base URI of the document. To set the base URI one should use parse_fh() as follows: my $doc = $parser->parse_fh( $io_fh, $baseuri ); =item parse_string $doc = $parser->parse_string( $xmlstring); This function is similar to parse_fh(), but it parses an XML document that is available as a single string in memory, or alternatively as a reference to a scalar containing a string. Again, you can pass an optional base URI to the function. my $doc = $parser->parse_string( $xmlstring, $baseuri ); my $doc = $parser->parse_string(\$xmlstring, $baseuri); =item parse_html_file $doc = $parser->parse_html_file( $htmlfile, \%opts ); Similar to parse_file() but parses HTML (strict) documents; $htmlfile can be filename or (non-HTTPS) URL. An optional second argument can be used to pass some options to the HTML parser as a HASH reference. See options labeled with HTML in L<<<<<< Parser Options >>>>>>. =item parse_html_fh $doc = $parser->parse_html_fh( $io_fh, \%opts ); Similar to parse_fh() but parses HTML (strict) streams. An optional second argument can be used to pass some options to the HTML parser as a HASH reference. See options labeled with HTML in L<<<<<< Parser Options >>>>>>. Note: encoding option may not work correctly with this function in libxml2 < 2.6.27 if the HTML file declares charset using a META tag. =item parse_html_string $doc = $parser->parse_html_string( $htmlstring, \%opts ); Similar to parse_string() but parses HTML (strict) strings. An optional second argument can be used to pass some options to the HTML parser as a HASH reference. See options labeled with HTML in L<<<<<< Parser Options >>>>>>. =back =head2 Push Parser XML::LibXML provides a push parser interface. Rather than pulling the data from a given source the push parser waits for the data to be pushed into it. This allows one to parse large documents without waiting for the parser to finish. The interface is especially useful if a program needs to pre-process the incoming pieces of XML (e.g. to detect document boundaries). While XML::LibXML parse_*() functions force the data to be a well-formed XML, the push parser will take any arbitrary string that contains some XML data. The only requirement is that all the pushed strings are together a well formed document. With the push parser interface a program can interrupt the parsing process as required, where the parse_*() functions give not enough flexibility. Different to the pull parser implemented in parse_fh() or parse_file(), the push parser is not able to find out about the documents end itself. Thus the calling program needs to indicate explicitly when the parsing is done. In XML::LibXML this is done by a single function: =over 4 =item parse_chunk $parser->parse_chunk($string, $terminate); parse_chunk() tries to parse a given chunk of data, which isn't necessarily well balanced data. The function takes two parameters: The chunk of data as a string and optional a termination flag. If the termination flag is set to a true value (e.g. 1), the parsing will be stopped and the resulting document will be returned as the following example describes: my $parser = XML::LibXML->new; for my $string ( "<", "foo", ' bar="hello world"', "/>") { $parser->parse_chunk( $string ); } my $doc = $parser->parse_chunk("", 1); # terminate the parsing =back Internally XML::LibXML provides three functions that control the push parser process: =over 4 =item init_push $parser->init_push(); Initializes the push parser. =item push $parser->push(@data); This function pushes the data stored inside the array to libxml2's parser. Each entry in @data must be a normal scalar! This method can be called repeatedly. =item finish_push $doc = $parser->finish_push( $recover ); This function returns the result of the parsing process. If this function is called without a parameter it will complain about non well-formed documents. If $restore is 1, the push parser can be used to restore broken or non well formed (XML) documents as the following example shows: eval { $parser->push( "", "bar" ); $doc = $parser->finish_push(); # will report broken XML }; if ( $@ ) { # ... } This can be annoying if the closing tag is missed by accident. The following code will restore the document: eval { $parser->push( "", "bar" ); $doc = $parser->finish_push(1); # will return the data parsed # unless an error happened }; print $doc->toString(); # returns "bar" Of course finish_push() will return nothing if there was no data pushed to the parser before. =back =head2 Pull Parser (Reader) XML::LibXML also provides a pull-parser interface similar to the XmlReader interface in .NET. This interface is almost streaming, and is usually faster and simpler to use than SAX. See L<<<<<< XML::LibXML::Reader >>>>>>. =head2 Direct SAX Parser XML::LibXML provides a direct SAX parser in the L<<<<<< XML::LibXML::SAX >>>>>> module. =head2 DOM based SAX Parser XML::LibXML also provides a DOM based SAX parser. The SAX parser is defined in the module XML::LibXML::SAX::Parser. As it is not a stream based parser, it parses documents into a DOM and traverses the DOM tree instead. The API of this parser is exactly the same as any other Perl SAX2 parser. See XML::SAX::Intro for details. Aside from the regular parsing methods, you can access the DOM tree traverser directly, using the generate() method: my $doc = build_yourself_a_document(); my $saxparser = $XML::LibXML::SAX::Parser->new( ... ); $parser->generate( $doc ); This is useful for serializing DOM trees, for example that you might have done prior processing on, or that you have as a result of XSLT processing. I<<<<<< WARNING >>>>>> This is NOT a streaming SAX parser. As I said above, this parser reads the entire document into a DOM and serialises it. Some people couldn't read that in the paragraph above so I've added this warning. If you want a streaming SAX parser look at the L<<<<<< XML::LibXML::SAX >>>>>> man page =head1 SERIALIZATION XML::LibXML provides some functions to serialize nodes and documents. The serialization functions are described on the L<<<<<< XML::LibXML::Node >>>>>> manpage or the L<<<<<< XML::LibXML::Document >>>>>> manpage. XML::LibXML checks three global flags that alter the serialization process: =over 4 =item * skipXMLDeclaration =item * skipDTD =item * setTagCompression =back of that three functions only setTagCompression is available for all serialization functions. Because XML::LibXML does these flags not itself, one has to define them locally as the following example shows: local $XML::LibXML::skipXMLDeclaration = 1; local $XML::LibXML::skipDTD = 1; local $XML::LibXML::setTagCompression = 1; If skipXMLDeclaration is defined and not '0', the XML declaration is omitted during serialization. If skipDTD is defined and not '0', an existing DTD would not be serialized with the document. If setTagCompression is defined and not '0' empty tags are displayed as open and closing tags rather than the shortcut. For example the empty tag I<<<<<< foo >>>>>> will be rendered as I<<<<<< EfooEE/fooE >>>>>> rather than I<<<<<< Efoo/E >>>>>>. =head1 PARSER OPTIONS Handling of libxml2 parser options has been unified and improved in XML::LibXML 1.70. You can now set default options for a particular parser instance by passing them to the constructor as C<<<<<< XML::LibXML-Enew({name=Evalue, ...}) >>>>>> or C<<<<<< XML::LibXML-Enew(name=Evalue,...) >>>>>>. The options can be queried and changed using the following methods (pre-1.70 interfaces such as C<<<<<< $parser-Eload_ext_dtd(0) >>>>>> also exist, see below): =over 4 =item option_exists $parser->option_exists($name); Returns 1 if the current XML::LibXML version supports the option C<<<<<< $name >>>>>>, otherwise returns 0 (note that this does not necessarily mean that the option is supported by the underlying libxml2 library). =item get_option $parser->get_option($name); Returns the current value of the parser option C<<<<<< $name >>>>>>. =item set_option $parser->set_option($name,$value); Sets option C<<<<<< $name >>>>>> to value C<<<<<< $value >>>>>>. =item set_options $parser->set_options({$name=>$value,...}); Sets multiple parsing options at once. =back IMPORTANT NOTE: This documentation reflects the parser flags available in libxml2 2.7.3. Some options have no effect if an older version of libxml2 is used. Each of the flags listed below is labeled =over 4 =item /parser/ if it can be used with a C<<<<<< XML::LibXML >>>>>> parser object (i.e. passed to C<<<<<< XML::LibXML-Enew >>>>>>, C<<<<<< XML::LibXML-Eset_option >>>>>>, etc.) =item /html/ if it can be used passed to the C<<<<<< parse_html_* >>>>>> methods =item /reader/ if it can be used with the C<<<<<< XML::LibXML::Reader >>>>>>. =back Unless specified otherwise, the default for boolean valued options is 0 (false). The available options are: =over 4 =item URI /parser, html, reader/ In case of parsing strings or file handles, XML::LibXML doesn't know about the base uri of the document. To make relative references such as XIncludes work, one has to set a base URI, that is then used for the parsed document. =item line_numbers /parser, html, reader/ If this option is activated, libxml2 will store the line number of each element node in the parsed document. The line number can be obtained using the C<<<<<< line_number() >>>>>> method of the C<<<<<< XML::LibXML::Node >>>>>> class (for non-element nodes this may report the line number of the containing element). The line numbers are also used for reporting positions of validation errors. IMPORTANT: Due to limitations in the libxml2 library line numbers greater than 65535 will be returned as 65535. Unfortunately, this is a long and sad story, please see L<<<<<< http://bugzilla.gnome.org/show_bug.cgi?id=325533 >>>>>> for more details. =item encoding /html/ character encoding of the input =item recover /parser, html, reader/ recover from errors; possible values are 0, 1, and 2 A true value turns on recovery mode which allows one to parse broken XML or HTML data. The recovery mode allows the parser to return the successfully parsed portion of the input document. This is useful for almost well-formed documents, where for example a closing tag is missing somewhere. Still, XML::LibXML will only parse until the first fatal (non-recoverable) error occurs, reporting recoverable parsing errors as warnings. To suppress even these warnings, use recover=>2. Note that validation is switched off automatically in recovery mode. =item expand_entities /parser, reader/ substitute entities; possible values are 0 and 1; default is 1 Note that although this flag disables entity substitution, it does not prevent the parser from loading external entities; when substitution of an external entity is disabled, the entity will be represented in the document tree by an XML_ENTITY_REF_NODE node whose subtree will be the content obtained by parsing the external resource; Although this nesting is visible from the DOM it is transparent to XPath data model, so it is possible to match nodes in an unexpanded entity by the same XPath expression as if the entity were expanded. See also ext_ent_handler. =item ext_ent_handler /parser/ Provide a custom external entity handler to be used when expand_entities is set to 1. Possible value is a subroutine reference. This feature does not work properly in libxml2 < 2.6.27! The subroutine provided is called whenever the parser needs to retrieve the content of an external entity. It is called with two arguments: the system ID (URI) and the public ID. The value returned by the subroutine is parsed as the content of the entity. This method can be used to completely disable entity loading, e.g. to prevent exploits of the type described at (L<<<<<< http://searchsecuritychannel.techtarget.com/generic/0,295582,sid97_gci1304703,00.html >>>>>>), where a service is tricked to expose its private data by letting it parse a remote file (RSS feed) that contains an entity reference to a local file (e.g. C<<<<<< /etc/fstab >>>>>>). A more granular solution to this problem, however, is provided by custom URL resolvers, as in my $c = XML::LibXML::InputCallback->new(); sub match { # accept file:/ URIs except for XML catalogs in /etc/xml/ my ($uri) = @_; return ($uri=~m{^file:/} and $uri !~ m{^file:///etc/xml/}) ? 1 : 0; } $c->register_callbacks([ \&match, sub{}, sub{}, sub{} ]); $parser->input_callbacks($c); =item load_ext_dtd /parser, reader/ load the external DTD subset while parsing; possible values are 0 and 1. Unless specified, XML::LibXML sets this option to 1. This flag is also required for DTD Validation, to provide complete attribute, and to expand entities, regardless if the document has an internal subset. Thus switching off external DTD loading, will disable entity expansion, validation, and complete attributes on internal subsets as well. =item complete_attributes /parser, reader/ create default DTD attributes; possible values are 0 and 1 =item validation /parser, reader/ validate with the DTD; possible values are 0 and 1 =item suppress_errors /parser, html, reader/ suppress error reports; possible values are 0 and 1 =item suppress_warnings /parser, html, reader/ suppress warning reports; possible values are 0 and 1 =item pedantic_parser /parser, html, reader/ pedantic error reporting; possible values are 0 and 1 =item no_blanks /parser, html, reader/ remove blank nodes; possible values are 0 and 1 =item no_defdtd /html/ do not add a default DOCTYPE; possible values are 0 and 1 the default is (0) to add a DTD when the input html lacks one =item expand_xinclude or xinclude /parser, reader/ Implement XInclude substitution; possible values are 0 and 1 Expands XInclude tags immediately while parsing the document. Note that the parser will use the URI resolvers installed via C<<<<<< XML::LibXML::InputCallback >>>>>> to parse the included document (if any). =item no_xinclude_nodes /parser, reader/ do not generate XINCLUDE START/END nodes; possible values are 0 and 1 =item no_network /parser, html, reader/ Forbid network access; possible values are 0 and 1 If set to true, all attempts to fetch non-local resources (such as DTD or external entities) will fail (unless custom callbacks are defined). It may be necessary to use the flag C<<<<<< recover >>>>>> for processing documents requiring such resources while networking is off. =item clean_namespaces /parser, reader/ remove redundant namespaces declarations during parsing; possible values are 0 and 1. =item no_cdata /parser, html, reader/ merge CDATA as text nodes; possible values are 0 and 1 =item no_basefix /parser, reader/ not fixup XINCLUDE xml#base URIS; possible values are 0 and 1 =item huge /parser, html, reader/ relax any hardcoded limit from the parser; possible values are 0 and 1. Unless specified, XML::LibXML sets this option to 0. Note: the default value for this option was changed to protect against denial of service through entity expansion attacks. Before enabling the option ensure you have taken alternative measures to protect your application against this type of attack. =item gdome /parser/ THIS OPTION IS EXPERIMENTAL! Although quite powerful, XML::LibXML's DOM implementation is incomplete with respect to the DOM level 2 or level 3 specifications. XML::GDOME is based on libxml2 as well, and provides a rather complete DOM implementation by wrapping libgdome. This flag allows you to make use of XML::LibXML's full parser options and XML::GDOME's DOM implementation at the same time. To make use of this function, one has to install libgdome and configure XML::LibXML to use this library. For this you need to rebuild XML::LibXML! Note: this feature was not seriously tested in recent XML::LibXML releases. =back For compatibility with XML::LibXML versions prior to 1.70, the following methods are also supported for querying and setting the corresponding parser options (if called without arguments, the methods return the current value of the corresponding parser options; with an argument sets the option to a given value): $parser->validation(); $parser->recover(); $parser->pedantic_parser(); $parser->line_numbers(); $parser->load_ext_dtd(); $parser->complete_attributes(); $parser->expand_xinclude(); $parser->gdome_dom(); $parser->clean_namespaces(); $parser->no_network(); The following obsolete methods trigger parser options in some special way: =over 4 =item recover_silently $parser->recover_silently(1); If called without an argument, returns true if the current value of the C<<<<<< recover >>>>>> parser option is 2 and returns false otherwise. With a true argument sets the C<<<<<< recover >>>>>> parser option to 2; with a false argument sets the C<<<<<< recover >>>>>> parser option to 0. =item expand_entities $parser->expand_entities(0); Get/set the C<<<<<< expand_entities >>>>>> option. If called with a true argument, also turns the C<<<<<< load_ext_dtd >>>>>> option to 1. =item keep_blanks $parser->keep_blanks(0); This is actually the opposite of the C<<<<<< no_blanks >>>>>> parser option. If used without an argument retrieves negated value of C<<<<<< no_blanks >>>>>>. If used with an argument sets C<<<<<< no_blanks >>>>>> to the opposite value. =item base_uri $parser->base_uri( $your_base_uri ); Get/set the C<<<<<< URI >>>>>> option. =back =head1 XML CATALOGS C<<<<<< libxml2 >>>>>> supports XML catalogs. Catalogs are used to map remote resources to their local copies. Using catalogs can speed up parsing processes if many external resources from remote addresses are loaded into the parsed documents (such as DTDs or XIncludes). Note that libxml2 has a global pool of loaded catalogs, so if you apply the method C<<<<<< load_catalog >>>>>> to one parser instance, all parser instances will start using the catalog (in addition to other previously loaded catalogs). Note also that catalogs are not used when a custom external entity handler is specified. At the current state it is not possible to make use of both types of resolving systems at the same time. =over 4 =item load_catalog $parser->load_catalog( $catalog_file ); Loads the XML catalog file $catalog_file. # Global external entity loader (similar to ext_ent_handler option # but this works really globally, also in XML::LibXSLT include etc..) XML::LibXML::externalEntityLoader(\&my_loader); =back =head1 ERROR REPORTING XML::LibXML throws exceptions during parsing, validation or XPath processing (and some other occasions). These errors can be caught by using I<<<<<< eval >>>>>> blocks. The error is stored in I<<<<<< $@ >>>>>>. There are two implementations: the old one throws $@ which is just a message string, in the new one $@ is an object from the class XML::LibXML::Error; this class overrides the operator "" so that when printed, the object flattens to the usual error message. XML::LibXML throws errors as they occur. This is a very common misunderstanding in the use of XML::LibXML. If the eval is omitted, XML::LibXML will always halt your script by "croaking" (see Carp man page for details). Also note that an increasing number of functions throw errors if bad data is passed as arguments. If you cannot assure valid data passed to XML::LibXML you should eval these functions. Note: since version 1.59, get_last_error() is no longer available in XML::LibXML for thread-safety reasons. =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]6,^&^&LibXML/InputCallback.podnu6$=head1 NAME XML::LibXML::InputCallback - XML::LibXML Class for Input Callbacks =head1 SYNOPSIS use XML::LibXML; =head1 DESCRIPTION You may get unexpected results if you are trying to load external documents during libxml2 parsing if the location of the resource is not a HTTP, FTP or relative location but a absolute path for example. To get around this limitation, you may add your own input handler to open, read and close particular types of locations or URI classes. Using this input callback handlers, you can handle your own custom URI schemes for example. The input callbacks are used whenever XML::LibXML has to get something other than externally parsed entities from somewhere. They are implemented using a callback stack on the Perl layer in analogy to libxml2's native callback stack. The XML::LibXML::InputCallback class transparently registers the input callbacks for the libxml2's parser processes. =head2 How does XML::LibXML::InputCallback work? The libxml2 library offers a callback implementation as global functions only. To work-around the troubles resulting in having only global callbacks - for example, if the same global callback stack is manipulated by different applications running together in a single Apache Web-server environment -, XML::LibXML::InputCallback comes with a object-oriented and a function-oriented part. Using the function-oriented part the global callback stack of libxml2 can be manipulated. Those functions can be used as interface to the callbacks on the C- and XS Layer. At the object-oriented part, operations for working with the "pseudo-localized" callback stack are implemented. Currently, you can register and de-register callbacks on the Perl layer and initialize them on a per parser basis. =head3 Callback Groups The libxml2 input callbacks come in groups. One group contains a URI matcher (I<<<<<< match >>>>>>), a data stream constructor (I<<<<<< open >>>>>>), a data stream reader (I<<<<<< read >>>>>>), and a data stream destructor (I<<<<<< close >>>>>>). The callbacks can be manipulated on a per group basis only. =head3 The Parser Process The parser process works on an XML data stream, along which, links to other resources can be embedded. This can be links to external DTDs or XIncludes for example. Those resources are identified by URIs. The callback implementation of libxml2 assumes that one callback group can handle a certain amount of URIs and a certain URI scheme. Per default, callback handlers for I<<<<<< file://* >>>>>>, I<<<<<< file:://*.gz >>>>>>, I<<<<<< http://* >>>>>> and I<<<<<< ftp://* >>>>>> are registered. Callback groups in the callback stack are processed from top to bottom, meaning that callback groups registered later will be processed before the earlier registered ones. While parsing the data stream, the libxml2 parser checks if a registered callback group will handle a URI - if they will not, the URI will be interpreted as I<<<<<< file://URI >>>>>>. To handle a URI, the I<<<<<< match >>>>>> callback will have to return '1'. If that happens, the handling of the URI will be passed to that callback group. Next, the URI will be passed to the I<<<<<< open >>>>>> callback, which should return a I<<<<<< reference >>>>>> to the data stream if it successfully opened the file, '0' otherwise. If opening the stream was successful, the I<<<<<< read >>>>>> callback will be called repeatedly until it returns an empty string. After the read callback, the I<<<<<< close >>>>>> callback will be called to close the stream. =head3 Organisation of callback groups in XML::LibXML::InputCallback Callback groups are implemented as a stack (Array), each entry holds a reference to an array of the callbacks. For the libxml2 library, the XML::LibXML::InputCallback callback implementation appears as one single callback group. The Perl implementation however allows one to manage different callback stacks on a per libxml2-parser basis. =head2 Using XML::LibXML::InputCallback After object instantiation using the parameter-less constructor, you can register callback groups. my $input_callbacks = XML::LibXML::InputCallback->new(); $input_callbacks->register_callbacks([ $match_cb1, $open_cb1, $read_cb1, $close_cb1 ] ); $input_callbacks->register_callbacks([ $match_cb2, $open_cb2, $read_cb2, $close_cb2 ] ); $input_callbacks->register_callbacks( [ $match_cb3, $open_cb3, $read_cb3, $close_cb3 ] ); $parser->input_callbacks( $input_callbacks ); $parser->parse_file( $some_xml_file ); =head2 What about the old callback system prior to XML::LibXML::InputCallback? In XML::LibXML versions prior to 1.59 - i.e. without the XML::LibXML::InputCallback module - you could define your callbacks either using globally or locally. You still can do that using XML::LibXML::InputCallback, and in addition to that you can define the callbacks on a per parser basis! If you use the old callback interface through global callbacks, XML::LibXML::InputCallback will treat them with a lower priority as the ones registered using the new interface. The global callbacks will not override the callback groups registered using the new interface. Local callbacks are attached to a specific parser instance, therefore they are treated with highest priority. If the I<<<<<< match >>>>>> callback of the callback group registered as local variable is identical to one of the callback groups registered using the new interface, that callback group will be replaced. Users of the old callback implementation whose I<<<<<< open >>>>>> callback returned a plain string, will have to adapt their code to return a reference to that string after upgrading to version >= 1.59. The new callback system can only deal with the I<<<<<< open >>>>>> callback returning a reference! =head1 INTERFACE DESCRIPTION =head2 Global Variables =over 4 =item $_CUR_CB Stores the current callback and can be used as shortcut to access the callback stack. =item @_GLOBAL_CALLBACKS Stores all callback groups for the current parser process. =item @_CB_STACK Stores the currently used callback group. Used to prevent parser errors when dealing with nested XML data. =back =head2 Global Callbacks =over 4 =item _callback_match Implements the interface for the I<<<<<< match >>>>>> callback at C-level and for the selection of the callback group from the callbacks defined at the Perl-level. =item _callback_open Forwards the I<<<<<< open >>>>>> callback from libxml2 to the corresponding callback function at the Perl-level. =item _callback_read Forwards the read request to the corresponding callback function at the Perl-level and returns the result to libxml2. =item _callback_close Forwards the I<<<<<< close >>>>>> callback from libxml2 to the corresponding callback function at the Perl-level.. =back =head2 Class methods =over 4 =item new() A simple constructor. =item register_callbacks( [ $match_cb, $open_cb, $read_cb, $close_cb ]) The four callbacks I<<<<<< have >>>>>> to be given as array reference in the above order I<<<<<< match >>>>>>, I<<<<<< open >>>>>>, I<<<<<< read >>>>>>, I<<<<<< close >>>>>>! =item unregister_callbacks( [ $match_cb, $open_cb, $read_cb, $close_cb ]) With no arguments given, C<<<<<< unregister_callbacks() >>>>>> will delete the last registered callback group from the stack. If four callbacks are passed as array reference, the callback group to unregister will be identified by the I<<<<<< match >>>>>> callback and deleted from the callback stack. Note that if several identical I<<<<<< match >>>>>> callbacks are defined in different callback groups, ALL of them will be deleted from the stack. =item init_callbacks( $parser ) Initializes the callback system for the provided parser before starting a parsing process. =item cleanup_callbacks() Resets global variables and the libxml2 callback stack. =item lib_init_callbacks() Used internally for callback registration at C-level. =item lib_cleanup_callbacks() Used internally for callback resetting at the C-level. =back =head1 EXAMPLE CALLBACKS The following example is a purely fictitious example that uses a MyScheme::Handler object that responds to methods similar to an IO::Handle. # Define the four callback functions sub match_uri { my $uri = shift; return $uri =~ /^myscheme:/; # trigger our callback group at a 'myscheme' URIs } sub open_uri { my $uri = shift; my $handler = MyScheme::Handler->new($uri); return $handler; } # The returned $buffer will be parsed by the libxml2 parser sub read_uri { my $handler = shift; my $length = shift; my $buffer; read($handler, $buffer, $length); return $buffer; # $buffer will be an empty string '' if read() is done } # Close the handle associated with the resource. sub close_uri { my $handler = shift; close($handler); } # Register them with a instance of XML::LibXML::InputCallback my $input_callbacks = XML::LibXML::InputCallback->new(); $input_callbacks->register_callbacks([ \&match_uri, \&open_uri, \&read_uri, \&close_uri ] ); # Register the callback group at a parser instance $parser->input_callbacks( $input_callbacks ); # $some_xml_file will be parsed using our callbacks $parser->parse_file( $some_xml_file ); =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]5aTTLibXML/Document.podnu6$=head1 NAME XML::LibXML::Document - XML::LibXML DOM Document Class =head1 SYNOPSIS use XML::LibXML; # Only methods specific to Document nodes are listed here, # see the XML::LibXML::Node manpage for other methods $dom = XML::LibXML::Document->new( $version, $encoding ); $dom = XML::LibXML::Document->createDocument( $version, $encoding ); $strURI = $doc->URI(); $doc->setURI($strURI); $strEncoding = $doc->encoding(); $strEncoding = $doc->actualEncoding(); $doc->setEncoding($new_encoding); $strVersion = $doc->version(); $doc->standalone $doc->setStandalone($numvalue); my $compression = $doc->compression; $doc->setCompression($ziplevel); $docstring = $dom->toString($format); $c14nstr = $doc->toStringC14N($comment_flag, $xpath_expression [, $xpath_context ]); $ec14nstr = $doc->toStringEC14N($comment_flag, $xpath_expression [, $xpath_context ], $inclusive_prefix_list); $str = $doc->serialize($format); $state = $doc->toFile($filename, $format); $state = $doc->toFH($fh, $format); $str = $document->toStringHTML(); $str = $document->serialize_html(); $bool = $dom->is_valid(); $dom->validate(); $root = $dom->documentElement(); $dom->setDocumentElement( $root ); $element = $dom->createElement( $nodename ); $element = $dom->createElementNS( $namespaceURI, $nodename ); $text = $dom->createTextNode( $content_text ); $comment = $dom->createComment( $comment_text ); $attrnode = $doc->createAttribute($name [,$value]); $attrnode = $doc->createAttributeNS( namespaceURI, $name [,$value] ); $fragment = $doc->createDocumentFragment(); $cdata = $dom->createCDATASection( $cdata_content ); my $pi = $doc->createProcessingInstruction( $target, $data ); my $entref = $doc->createEntityReference($refname); $dtd = $document->createInternalSubset( $rootnode, $public, $system); $dtd = $document->createExternalSubset( $rootnode_name, $publicId, $systemId); $document->importNode( $node ); $document->adoptNode( $node ); my $dtd = $doc->externalSubset; my $dtd = $doc->internalSubset; $doc->setExternalSubset($dtd); $doc->setInternalSubset($dtd); my $dtd = $doc->removeExternalSubset(); my $dtd = $doc->removeInternalSubset(); my @nodelist = $doc->getElementsByTagName($tagname); my @nodelist = $doc->getElementsByTagNameNS($nsURI,$tagname); my @nodelist = $doc->getElementsByLocalName($localname); my $node = $doc->getElementById($id); $dom->indexElements(); =head1 DESCRIPTION The Document Class is in most cases the result of a parsing process. But sometimes it is necessary to create a Document from scratch. The DOM Document Class provides functions that conform to the DOM Core naming style. It inherits all functions from L<<<<<< XML::LibXML::Node >>>>>> as specified in the DOM specification. This enables access to the nodes besides the root element on document level - a C<<<<<< DTD >>>>>> for example. The support for these nodes is limited at the moment. While generally nodes are bound to a document in the DOM concept it is suggested that one should always create a node not bound to any document. There is no need of really including the node to the document, but once the node is bound to a document, it is quite safe that all strings have the correct encoding. If an unbound text node with an ISO encoded string is created (e.g. with $CLASS->new()), the C<<<<<< toString >>>>>> function may not return the expected result. To prevent such problems, it is recommended to pass all data to XML::LibXML methods as character strings (i.e. UTF-8 encoded, with the UTF8 flag on). =head1 METHODS Many functions listed here are extensively documented in the DOM Level 3 specification (L<<<<<< http://www.w3.org/TR/DOM-Level-3-Core/ >>>>>>). Please refer to the specification for extensive documentation. =over 4 =item new $dom = XML::LibXML::Document->new( $version, $encoding ); alias for createDocument() =item createDocument $dom = XML::LibXML::Document->createDocument( $version, $encoding ); The constructor for the document class. As Parameter it takes the version string and (optionally) the encoding string. Simply calling I<<<<<< createDocument >>>>>>() will create the document: Both parameter are optional. The default value for I<<<<<< $version >>>>>> is C<<<<<< 1.0 >>>>>>, of course. If the I<<<<<< $encoding >>>>>> parameter is not set, the encoding will be left unset, which means UTF-8 is implied. The call of I<<<<<< createDocument >>>>>>() without any parameter will result the following code: Alternatively one can call this constructor directly from the XML::LibXML class level, to avoid some typing. This will not have any effect on the class instance, which is always XML::LibXML::Document. my $document = XML::LibXML->createDocument( "1.0", "UTF-8" ); is therefore a shortcut for my $document = XML::LibXML::Document->createDocument( "1.0", "UTF-8" ); =item URI $strURI = $doc->URI(); Returns the URI (or filename) of the original document. For documents obtained by parsing a string of a FH without using the URI parsing argument of the corresponding C<<<<<< parse_* >>>>>> function, the result is a generated string unknown-XYZ where XYZ is some number; for documents created with the constructor C<<<<<< new >>>>>>, the URI is undefined. The value can be modified by calling C<<<<<< setURI >>>>>> method on the document node. =item setURI $doc->setURI($strURI); Sets the URI of the document reported by the method URI (see also the URI argument to the various C<<<<<< parse_* >>>>>> functions). =item encoding $strEncoding = $doc->encoding(); returns the encoding string of the document. my $doc = XML::LibXML->createDocument( "1.0", "ISO-8859-15" ); print $doc->encoding; # prints ISO-8859-15 =item actualEncoding $strEncoding = $doc->actualEncoding(); returns the encoding in which the XML will be returned by $doc->toString(). This is usually the original encoding of the document as declared in the XML declaration and returned by $doc->encoding. If the original encoding is not known (e.g. if created in memory or parsed from a XML without a declared encoding), 'UTF-8' is returned. my $doc = XML::LibXML->createDocument( "1.0", "ISO-8859-15" ); print $doc->encoding; # prints ISO-8859-15 =item setEncoding $doc->setEncoding($new_encoding); This method allows one to change the declaration of encoding in the XML declaration of the document. The value also affects the encoding in which the document is serialized to XML by $doc->toString(). Use setEncoding() to remove the encoding declaration. =item version $strVersion = $doc->version(); returns the version string of the document I<<<<<< getVersion() >>>>>> is an alternative form of this function. =item standalone $doc->standalone This function returns the Numerical value of a documents XML declarations standalone attribute. It returns I<<<<<< 1 >>>>>> if standalone="yes" was found, I<<<<<< 0 >>>>>> if standalone="no" was found and I<<<<<< -1 >>>>>> if standalone was not specified (default on creation). =item setStandalone $doc->setStandalone($numvalue); Through this method it is possible to alter the value of a documents standalone attribute. Set it to I<<<<<< 1 >>>>>> to set standalone="yes", to I<<<<<< 0 >>>>>> to set standalone="no" or set it to I<<<<<< -1 >>>>>> to remove the standalone attribute from the XML declaration. =item compression my $compression = $doc->compression; libxml2 allows reading of documents directly from gzipped files. In this case the compression variable is set to the compression level of that file (0-8). If XML::LibXML parsed a different source or the file wasn't compressed, the returned value will be I<<<<<< -1 >>>>>>. =item setCompression $doc->setCompression($ziplevel); If one intends to write the document directly to a file, it is possible to set the compression level for a given document. This level can be in the range from 0 to 8. If XML::LibXML should not try to compress use I<<<<<< -1 >>>>>> (default). Note that this feature will I<<<<<< only >>>>>> work if libxml2 is compiled with zlib support and toFile() is used for output. =item toString $docstring = $dom->toString($format); I<<<<<< toString >>>>>> is a DOM serializing function, so the DOM Tree is serialized into an XML string, ready for output. IMPORTANT: unlike toString for other nodes, on document nodes this function returns the XML as a byte string in the original encoding of the document (see the actualEncoding() method)! This means you can simply do: open my $out_fh, '>', $file; print {$out_fh} $doc->toString; regardless of the actual encoding of the document. See the section on encodings in L<<<<<< XML::LibXML >>>>>> for more details. The optional I<<<<<< $format >>>>>> parameter sets the indenting of the output. This parameter is expected to be an C<<<<<< integer >>>>>> value, that specifies that indentation should be used. The format parameter can have three different values if it is used: If $format is 0, than the document is dumped as it was originally parsed If $format is 1, libxml2 will add ignorable white spaces, so the nodes content is easier to read. Existing text nodes will not be altered If $format is 2 (or higher), libxml2 will act as $format == 1 but it add a leading and a trailing line break to each text node. libxml2 uses a hard-coded indentation of 2 space characters per indentation level. This value can not be altered on run-time. =item toStringC14N $c14nstr = $doc->toStringC14N($comment_flag, $xpath_expression [, $xpath_context ]); See the documentation in L<<<<<< XML::LibXML::Node >>>>>>. =item toStringEC14N $ec14nstr = $doc->toStringEC14N($comment_flag, $xpath_expression [, $xpath_context ], $inclusive_prefix_list); See the documentation in L<<<<<< XML::LibXML::Node >>>>>>. =item serialize $str = $doc->serialize($format); An alias for toString(). This function was name added to be more consistent with libxml2. =item serialize_c14n An alias for toStringC14N(). =item serialize_exc_c14n An alias for toStringEC14N(). =item toFile $state = $doc->toFile($filename, $format); This function is similar to toString(), but it writes the document directly into a filesystem. This function is very useful, if one needs to store large documents. The format parameter has the same behaviour as in toString(). =item toFH $state = $doc->toFH($fh, $format); This function is similar to toString(), but it writes the document directly to a filehandle or a stream. A byte stream in the document encoding is passed to the file handle. Do NOT apply any C<<<<<< :encoding(...) >>>>>> or C<<<<<< :utf8 >>>>>> PerlIO layer to the filehandle! See the section on encodings in L<<<<<< XML::LibXML >>>>>> for more details. The format parameter has the same behaviour as in toString(). =item toStringHTML $str = $document->toStringHTML(); I<<<<<< toStringHTML >>>>>> serialize the tree to a byte string in the document encoding as HTML. With this method indenting is automatic and managed by libxml2 internally. Note the string must contain (rather than the newer ), else all non-ASCII will become entities. =item serialize_html $str = $document->serialize_html(); An alias for toStringHTML(). =item is_valid $bool = $dom->is_valid(); Returns either TRUE or FALSE depending on whether the DOM Tree is a valid Document or not. You may also pass in a L<<<<<< XML::LibXML::Dtd >>>>>> object, to validate against an external DTD: if (!$dom->is_valid($dtd)) { warn("document is not valid!"); } =item validate $dom->validate(); This is an exception throwing equivalent of is_valid. If the document is not valid it will throw an exception containing the error. This allows you much better error reporting than simply is_valid or not. Again, you may pass in a DTD object =item documentElement $root = $dom->documentElement(); Returns the root element of the Document. A document can have just one root element to contain the documents data. Optionally one can use I<<<<<< getDocumentElement >>>>>>. =item setDocumentElement $dom->setDocumentElement( $root ); This function enables you to set the root element for a document. The function supports the import of a node from a different document tree, but does not support a document fragment as $root. =item createElement $element = $dom->createElement( $nodename ); This function creates a new Element Node bound to the DOM with the name C<<<<<< $nodename >>>>>>. =item createElementNS $element = $dom->createElementNS( $namespaceURI, $nodename ); This function creates a new Element Node bound to the DOM with the name C<<<<<< $nodename >>>>>> and placed in the given namespace. =item createTextNode $text = $dom->createTextNode( $content_text ); As an equivalent of I<<<<<< createElement >>>>>>, but it creates a I<<<<<< Text Node >>>>>> bound to the DOM. =item createComment $comment = $dom->createComment( $comment_text ); As an equivalent of I<<<<<< createElement >>>>>>, but it creates a I<<<<<< Comment Node >>>>>> bound to the DOM. =item createAttribute $attrnode = $doc->createAttribute($name [,$value]); Creates a new Attribute node. =item createAttributeNS $attrnode = $doc->createAttributeNS( namespaceURI, $name [,$value] ); Creates an Attribute bound to a namespace. =item createDocumentFragment $fragment = $doc->createDocumentFragment(); This function creates a DocumentFragment. =item createCDATASection $cdata = $dom->createCDATASection( $cdata_content ); Similar to createTextNode and createComment, this function creates a CDataSection bound to the current DOM. =item createProcessingInstruction my $pi = $doc->createProcessingInstruction( $target, $data ); create a processing instruction node. Since this method is quite long one may use its short form I<<<<<< createPI() >>>>>>. =item createEntityReference my $entref = $doc->createEntityReference($refname); If a document has a DTD specified, one can create entity references by using this function. If one wants to add a entity reference to the document, this reference has to be created by this function. An entity reference is unique to a document and cannot be passed to other documents as other nodes can be passed. I<<<<<< NOTE: >>>>>> A text content containing something that looks like an entity reference, will not be expanded to a real entity reference unless it is a predefined entity my $string = "&foo;"; $some_element->appendText( $string ); print $some_element->textContent; # prints "&foo;" =item createInternalSubset $dtd = $document->createInternalSubset( $rootnode, $public, $system); This function creates and adds an internal subset to the given document. Because the function automatically adds the DTD to the document there is no need to add the created node explicitly to the document. my $document = XML::LibXML::Document->new(); my $dtd = $document->createInternalSubset( "foo", undef, "foo.dtd" ); will result in the following XML document: By setting the public parameter it is possible to set PUBLIC DTDs to a given document. So my $document = XML::LibXML::Document->new(); my $dtd = $document->createInternalSubset( "foo", "-//FOO//DTD FOO 0.1//EN", undef ); will cause the following declaration to be created on the document: =item createExternalSubset $dtd = $document->createExternalSubset( $rootnode_name, $publicId, $systemId); This function is similar to C<<<<<< createInternalSubset() >>>>>> but this DTD is considered to be external and is therefore not added to the document itself. Nevertheless it can be used for validation purposes. =item importNode $document->importNode( $node ); If a node is not part of a document, it can be imported to another document. As specified in DOM Level 2 Specification the Node will not be altered or removed from its original document (C<<<<<< $node-EcloneNode(1) >>>>>> will get called implicitly). I<<<<<< NOTE: >>>>>> Don't try to use importNode() to import sub-trees that contain an entity reference - even if the entity reference is the root node of the sub-tree. This will cause serious problems to your program. This is a limitation of libxml2 and not of XML::LibXML itself. =item adoptNode $document->adoptNode( $node ); If a node is not part of a document, it can be imported to another document. As specified in DOM Level 3 Specification the Node will not be altered but it will removed from its original document. After a document adopted a node, the node, its attributes and all its descendants belong to the new document. Because the node does not belong to the old document, it will be unlinked from its old location first. I<<<<<< NOTE: >>>>>> Don't try to adoptNode() to import sub-trees that contain entity references - even if the entity reference is the root node of the sub-tree. This will cause serious problems to your program. This is a limitation of libxml2 and not of XML::LibXML itself. =item externalSubset my $dtd = $doc->externalSubset; If a document has an external subset defined it will be returned by this function. I<<<<<< NOTE >>>>>> Dtd nodes are no ordinary nodes in libxml2. The support for these nodes in XML::LibXML is still limited. In particular one may not want use common node function on doctype declaration nodes! =item internalSubset my $dtd = $doc->internalSubset; If a document has an internal subset defined it will be returned by this function. I<<<<<< NOTE >>>>>> Dtd nodes are no ordinary nodes in libxml2. The support for these nodes in XML::LibXML is still limited. In particular one may not want use common node function on doctype declaration nodes! =item setExternalSubset $doc->setExternalSubset($dtd); I<<<<<< EXPERIMENTAL! >>>>>> This method sets a DTD node as an external subset of the given document. =item setInternalSubset $doc->setInternalSubset($dtd); I<<<<<< EXPERIMENTAL! >>>>>> This method sets a DTD node as an internal subset of the given document. =item removeExternalSubset my $dtd = $doc->removeExternalSubset(); I<<<<<< EXPERIMENTAL! >>>>>> If a document has an external subset defined it can be removed from the document by using this function. The removed dtd node will be returned. =item removeInternalSubset my $dtd = $doc->removeInternalSubset(); I<<<<<< EXPERIMENTAL! >>>>>> If a document has an internal subset defined it can be removed from the document by using this function. The removed dtd node will be returned. =item getElementsByTagName my @nodelist = $doc->getElementsByTagName($tagname); Implements the DOM Level 2 function In SCALAR context this function returns an L<<<<<< XML::LibXML::NodeList >>>>>> object. =item getElementsByTagNameNS my @nodelist = $doc->getElementsByTagNameNS($nsURI,$tagname); Implements the DOM Level 2 function In SCALAR context this function returns an L<<<<<< XML::LibXML::NodeList >>>>>> object. =item getElementsByLocalName my @nodelist = $doc->getElementsByLocalName($localname); This allows the fetching of all nodes from a given document with the given Localname. In SCALAR context this function returns an L<<<<<< XML::LibXML::NodeList >>>>>> object. =item getElementById my $node = $doc->getElementById($id); Returns the element that has an ID attribute with the given value. If no such element exists, this returns undef. Note: the ID of an element may change while manipulating the document. For documents with a DTD, the information about ID attributes is only available if DTD loading/validation has been requested. For HTML documents parsed with the HTML parser ID detection is done automatically. In XML documents, all "xml:id" attributes are considered to be of type ID. You can test ID-ness of an attribute node with $attr->isId(). In versions 1.59 and earlier this method was called getElementsById() (plural) by mistake. Starting from 1.60 this name is maintained as an alias only for backward compatibility. =item indexElements $dom->indexElements(); This function causes libxml2 to stamp all elements in a document with their document position index which considerably speeds up XPath queries for large documents. It should only be used with static documents that won't be further changed by any DOM methods, because once a document is indexed, XPath will always prefer the index to other methods of determining the document order of nodes. XPath could therefore return improperly ordered node-lists when applied on a document that has been changed after being indexed. It is of course possible to use this method to re-index a modified document before using it with XPath again. This function is not a part of the DOM specification. This function returns number of elements indexed, -1 if error occurred, or -2 if this feature is not available in the running libxml2. =back =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]Ϋ..LibXML/NodeList.pmnu6$# $Id$ # # This is free software, you may use it and distribute it under the same terms as # Perl itself. # # Copyright 2001-2003 AxKit.com Ltd., 2002-2006 Christian Glahn, 2006-2009 Petr Pajas # # package XML::LibXML::NodeList; use strict; use warnings; use XML::LibXML::Boolean; use XML::LibXML::Literal; use XML::LibXML::Number; our $VERSION = "2.0213"; # VERSION TEMPLATE: DO NOT CHANGE use overload '""' => \&to_literal, 'bool' => \&to_boolean, 'cmp' => sub { my($aa, $bb, $order) = @_; return ($order ? ("$bb" cmp "$aa") : ("$aa" cmp "$bb")); }, ; sub new { my $class = shift; bless [@_], $class; } sub new_from_ref { my ($class,$array_ref,$reuse) = @_; return bless $reuse ? $array_ref : [@$array_ref], $class; } sub pop { my $self = CORE::shift; CORE::pop @$self; } sub push { my $self = CORE::shift; CORE::push @$self, @_; } sub append { my $self = CORE::shift; my ($nodelist) = @_; CORE::push @$self, $nodelist->get_nodelist; } sub shift { my $self = CORE::shift; CORE::shift @$self; } sub unshift { my $self = CORE::shift; CORE::unshift @$self, @_; } sub prepend { my $self = CORE::shift; my ($nodelist) = @_; CORE::unshift @$self, $nodelist->get_nodelist; } sub size { my $self = CORE::shift; scalar @$self; } sub get_node { # uses array index starting at 1, not 0 # this is mainly because of XPath. my $self = CORE::shift; my ($pos) = @_; $self->[$pos - 1]; } sub item { my ($self, $pos) = @_; return $self->[$pos]; } sub get_nodelist { my $self = CORE::shift; @$self; } sub to_boolean { my $self = CORE::shift; return (@$self > 0) ? XML::LibXML::Boolean->True : XML::LibXML::Boolean->False; } # string-value of a nodelist is the string-value of the first node sub string_value { my $self = CORE::shift; return '' unless @$self; return $self->[0]->string_value; } sub to_literal { my $self = CORE::shift; return XML::LibXML::Literal->new( join('', CORE::grep {defined $_} CORE::map { $_->string_value } @$self) ); } sub to_literal_delimited { my $self = CORE::shift; return XML::LibXML::Literal->new( join(CORE::shift, CORE::grep {defined $_} CORE::map { $_->string_value } @$self) ); } sub to_literal_list { my $self = CORE::shift; my @nodes = CORE::map{ XML::LibXML::Literal->new($_->string_value())->value() } @{$self}; if (wantarray) { return( @nodes ); } return( \@nodes ); } sub to_number { my $self = CORE::shift; return XML::LibXML::Number->new( $self->to_literal ); } sub iterator { warn "this function is obsolete!\nIt was disabled in version 1.54\n"; return undef; } sub map { my $self = CORE::shift; my $sub = __is_code(CORE::shift); local $_; my @results = CORE::map { @{[ $sub->($_) ]} } @$self; return unless defined wantarray; return wantarray ? @results : (ref $self)->new(@results); } sub grep { my $self = CORE::shift; my $sub = __is_code(CORE::shift); local $_; my @results = CORE::grep { $sub->($_) } @$self; return unless defined wantarray; return wantarray ? @results : (ref $self)->new(@results); } sub sort { my $self = CORE::shift; my $sub = __is_code(CORE::shift); my @results = CORE::sort { $sub->($a,$b) } @$self; return wantarray ? @results : (ref $self)->new(@results); } sub foreach { my $self = CORE::shift; my $sub = CORE::shift; foreach my $item (@$self) { local $_ = $item; $sub->($item); } return wantarray ? @$self : $self; } sub reverse { my $self = CORE::shift; my @results = CORE::reverse @$self; return wantarray ? @results : (ref $self)->new(@results); } sub reduce { my $self = CORE::shift; my $sub = __is_code(CORE::shift); my @list = @$self; CORE::unshift @list, $_[0] if @_; my $a = CORE::shift(@list); foreach my $b (@list) { $a = $sub->($a, $b); } return $a; } sub __is_code { my ($code) = @_; if (ref $code eq 'CODE') { return $code; } # There are better ways of doing this, but here I've tried to # avoid adding any additional external dependencies. # if (UNIVERSAL::can($code, 'can') # is blessed (sort of) and overload::Overloaded($code) # is overloaded and overload::Method($code, '&{}')) { # overloads '&{}' return $code; } # The other possibility is that $code is a coderef, but is # blessed into a class that doesn't overload '&{}'. In which # case... well, I'm stumped! die "Not a subroutine reference\n"; } 1; __END__ =head1 NAME XML::LibXML::NodeList - a list of XML document nodes =head1 DESCRIPTION An XML::LibXML::NodeList object contains an ordered list of nodes, as detailed by the W3C DOM documentation of Node Lists. =head1 SYNOPSIS my $results = $dom->findnodes('//somepath'); foreach my $context ($results->get_nodelist) { my $newresults = $context->findnodes('./other/element'); ... } =head1 API =head2 new(@nodes) You will almost never have to create a new NodeList object, as it is all done for you by XPath. =head2 get_nodelist() Returns a list of nodes, the contents of the node list, as a perl list. =head2 string_value() Returns the string-value of the first node in the list. See the XPath specification for what "string-value" means. =head2 to_literal() Returns the concatenation of all the string-values of all the nodes in the list. =head2 to_literal_delimited($separator) Returns the concatenation of all the string-values of all the nodes in the list, delimited by the specified separator. =head2 to_literal_list() Returns all the string-values of all the nodes in the list as a perl list. =head2 get_node($pos) Returns the node at $pos. The node position in XPath is based at 1, not 0. =head2 size() Returns the number of nodes in the NodeList. =head2 pop() Equivalent to perl's pop function. =head2 push(@nodes) Equivalent to perl's push function. =head2 append($nodelist) Given a nodelist, appends the list of nodes in $nodelist to the end of the current list. =head2 shift() Equivalent to perl's shift function. =head2 unshift(@nodes) Equivalent to perl's unshift function. =head2 prepend($nodelist) Given a nodelist, prepends the list of nodes in $nodelist to the front of the current list. =head2 map($coderef) Equivalent to perl's map function. =head2 grep($coderef) Equivalent to perl's grep function. =head2 sort($coderef) Equivalent to perl's sort function. Caveat: Perl's magic C<$a> and C<$b> variables are not available in C<$coderef>. Instead the two terms are passed to the coderef as arguments. =head2 reverse() Equivalent to perl's reverse function. =head2 foreach($coderef) Inspired by perl's foreach loop. Executes the coderef on each item in the list. Similar to C, but instead of returning the list of values returned by $coderef, returns the original NodeList. =head2 reduce($coderef, $init) Equivalent to List::Util's reduce function. C<$init> is optional and provides an initial value for the reduction. Caveat: Perl's magic C<$a> and C<$b> variables are not available in C<$coderef>. Instead the two terms are passed to the coderef as arguments. =cut PKM]A*LibXML/Dtd.podnu6$=head1 NAME XML::LibXML::Dtd - XML::LibXML DTD Handling =head1 SYNOPSIS use XML::LibXML; $dtd = XML::LibXML::Dtd->new($public_id, $system_id); $dtd = XML::LibXML::Dtd->parse_string($dtd_str); $publicId = $dtd->getName(); $publicId = $dtd->publicId(); $systemId = $dtd->systemId(); =head1 DESCRIPTION This class holds a DTD. You may parse a DTD from either a string, or from an external SYSTEM identifier. No support is available as yet for parsing from a filehandle. XML::LibXML::Dtd is a sub-class of L<<<<<< XML::LibXML::Node >>>>>>, so all the methods available to nodes (particularly toString()) are available to Dtd objects. =head1 METHODS =over 4 =item new $dtd = XML::LibXML::Dtd->new($public_id, $system_id); Parse a DTD from the system identifier, and return a DTD object that you can pass to $doc->is_valid() or $doc->validate(). my $dtd = XML::LibXML::Dtd->new( "SOME // Public / ID / 1.0", "test.dtd" ); my $doc = XML::LibXML->new->parse_file("test.xml"); $doc->validate($dtd); =item parse_string $dtd = XML::LibXML::Dtd->parse_string($dtd_str); The same as new() above, except you can parse a DTD from a string. Note that parsing from string may fail if the DTD contains external parametric-entity references with relative URLs. =item getName $publicId = $dtd->getName(); Returns the name of DTD; i.e., the name immediately following the DOCTYPE keyword. =item publicId $publicId = $dtd->publicId(); Returns the public identifier of the external subset. =item systemId $systemId = $dtd->systemId(); Returns the system identifier of the external subset. =back =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]W" " LibXML/Namespace.podnu6$=head1 NAME XML::LibXML::Namespace - XML::LibXML Namespace Implementation =head1 SYNOPSIS use XML::LibXML; # Only methods specific to Namespace nodes are listed here, # see the XML::LibXML::Node manpage for other methods my $ns = XML::LibXML::Namespace->new($nsURI); print $ns->nodeName(); print $ns->name(); $localname = $ns->getLocalName(); print $ns->getData(); print $ns->getValue(); print $ns->value(); $known_uri = $ns->getNamespaceURI(); $known_prefix = $ns->getPrefix(); $key = $ns->unique_key(); =head1 DESCRIPTION Namespace nodes are returned by both $element->findnodes('namespace::foo') or by $node->getNamespaces(). The namespace node API is not part of any current DOM API, and so it is quite minimal. It should be noted that namespace nodes are I<<<<<< not >>>>>> a sub class of L<<<<<< XML::LibXML::Node >>>>>>, however Namespace nodes act a lot like attribute nodes, and similarly named methods will return what you would expect if you treated the namespace node as an attribute. Note that in order to fix several inconsistencies between the API and the documentation, the behavior of some functions have been changed in 1.64. =head1 METHODS =over 4 =item new my $ns = XML::LibXML::Namespace->new($nsURI); Creates a new Namespace node. Note that this is not a 'node' as an attribute or an element node. Therefore you can't do call all L<<<<<< XML::LibXML::Node >>>>>> Functions. All functions available for this node are listed below. Optionally you can pass the prefix to the namespace constructor. If this second parameter is omitted you will create a so called default namespace. Note, the newly created namespace is not bound to any document or node, therefore you should not expect it to be available in an existing document. =item declaredURI Returns the URI for this namespace. =item declaredPrefix Returns the prefix for this namespace. =item nodeName print $ns->nodeName(); Returns "xmlns:prefix", where prefix is the prefix for this namespace. =item name print $ns->name(); Alias for nodeName() =item getLocalName $localname = $ns->getLocalName(); Returns the local name of this node as if it were an attribute, that is, the prefix associated with the namespace. =item getData print $ns->getData(); Returns the URI of the namespace, i.e. the value of this node as if it were an attribute. =item getValue print $ns->getValue(); Alias for getData() =item value print $ns->value(); Alias for getData() =item getNamespaceURI $known_uri = $ns->getNamespaceURI(); Returns the string "http://www.w3.org/2000/xmlns/" =item getPrefix $known_prefix = $ns->getPrefix(); Returns the string "xmlns" =item unique_key $key = $ns->unique_key(); This method returns a key guaranteed to be unique for this namespace, and to always be the same value for this namespace. Two namespace objects return the same key if and only if they have the same prefix and the same URI. The returned key value is useful as a key in hashes. =back =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]vKx55LibXML/Element.podnu6$=head1 NAME XML::LibXML::Element - XML::LibXML Class for Element Nodes =head1 SYNOPSIS use XML::LibXML; # Only methods specific to Element nodes are listed here, # see the XML::LibXML::Node manpage for other methods $node = XML::LibXML::Element->new( $name ); $node->setAttribute( $aname, $avalue ); $node->setAttributeNS( $nsURI, $aname, $avalue ); $avalue = $node->getAttribute( $aname ); $avalue = $node->getAttributeNS( $nsURI, $aname ); $attrnode = $node->getAttributeNode( $aname ); $attrnode = $node->getAttributeNodeNS( $namespaceURI, $aname ); $node->removeAttribute( $aname ); $node->removeAttributeNS( $nsURI, $aname ); $boolean = $node->hasAttribute( $aname ); $boolean = $node->hasAttributeNS( $nsURI, $aname ); @nodes = $node->getChildrenByTagName($tagname); @nodes = $node->getChildrenByTagNameNS($nsURI,$tagname); @nodes = $node->getChildrenByLocalName($localname); @nodes = $node->getElementsByTagName($tagname); @nodes = $node->getElementsByTagNameNS($nsURI,$localname); @nodes = $node->getElementsByLocalName($localname); $node->appendWellBalancedChunk( $chunk ); $node->appendText( $PCDATA ); $node->appendTextNode( $PCDATA ); $node->appendTextChild( $childname , $PCDATA ); $node->setNamespace( $nsURI , $nsPrefix, $activate ); $node->setNamespaceDeclURI( $nsPrefix, $newURI ); $node->setNamespaceDeclPrefix( $oldPrefix, $newPrefix ); =head1 METHODS The class inherits from L<<<<<< XML::LibXML::Node >>>>>>. The documentation for Inherited methods is not listed here. Many functions listed here are extensively documented in the DOM Level 3 specification (L<<<<<< http://www.w3.org/TR/DOM-Level-3-Core/ >>>>>>). Please refer to the specification for extensive documentation. =over 4 =item new $node = XML::LibXML::Element->new( $name ); This function creates a new node unbound to any DOM. =item setAttribute $node->setAttribute( $aname, $avalue ); This method sets or replaces the node's attribute C<<<<<< $aname >>>>>> to the value C<<<<<< $avalue >>>>>> =item setAttributeNS $node->setAttributeNS( $nsURI, $aname, $avalue ); Namespace-aware version of C<<<<<< setAttribute >>>>>>, where C<<<<<< $nsURI >>>>>> is a namespace URI, C<<<<<< $aname >>>>>> is a qualified name, and C<<<<<< $avalue >>>>>> is the value. The namespace URI may be null (empty or undefined) in order to create an attribute which has no namespace. The current implementation differs from DOM in the following aspects If an attribute with the same local name and namespace URI already exists on the element, but its prefix differs from the prefix of C<<<<<< $aname >>>>>>, then this function is supposed to change the prefix (regardless of namespace declarations and possible collisions). However, the current implementation does rather the opposite. If a prefix is declared for the namespace URI in the scope of the attribute, then the already declared prefix is used, disregarding the prefix specified in C<<<<<< $aname >>>>>>. If no prefix is declared for the namespace, the function tries to declare the prefix specified in C<<<<<< $aname >>>>>> and dies if the prefix is already taken by some other namespace. According to DOM Level 2 specification, this method can also be used to create or modify special attributes used for declaring XML namespaces (which belong to the namespace "http://www.w3.org/2000/xmlns/" and have prefix or name "xmlns"). This should work since version 1.61, but again the implementation differs from DOM specification in the following: if a declaration of the same namespace prefix already exists on the element, then changing its value via this method automatically changes the namespace of all elements and attributes in its scope. This is because in libxml2 the namespace URI of an element is not static but is computed from a pointer to a namespace declaration attribute. =item getAttribute $avalue = $node->getAttribute( $aname ); If C<<<<<< $node >>>>>> has an attribute with the name C<<<<<< $aname >>>>>>, the value of this attribute will get returned. =item getAttributeNS $avalue = $node->getAttributeNS( $nsURI, $aname ); Retrieves an attribute value by local name and namespace URI. =item getAttributeNode $attrnode = $node->getAttributeNode( $aname ); Retrieve an attribute node by name. If no attribute with a given name exists, C<<<<<< undef >>>>>> is returned. =item getAttributeNodeNS $attrnode = $node->getAttributeNodeNS( $namespaceURI, $aname ); Retrieves an attribute node by local name and namespace URI. If no attribute with a given localname and namespace exists, C<<<<<< undef >>>>>> is returned. =item removeAttribute $node->removeAttribute( $aname ); The method removes the attribute C<<<<<< $aname >>>>>> from the node's attribute list, if the attribute can be found. =item removeAttributeNS $node->removeAttributeNS( $nsURI, $aname ); Namespace version of C<<<<<< removeAttribute >>>>>> =item hasAttribute $boolean = $node->hasAttribute( $aname ); This function tests if the named attribute is set for the node. If the attribute is specified, TRUE (1) will be returned, otherwise the return value is FALSE (0). =item hasAttributeNS $boolean = $node->hasAttributeNS( $nsURI, $aname ); namespace version of C<<<<<< hasAttribute >>>>>> =item getChildrenByTagName @nodes = $node->getChildrenByTagName($tagname); The function gives direct access to all child elements of the current node with a given tagname, where tagname is a qualified name, that is, in case of namespace usage it may consist of a prefix and local name. This function makes things a lot easier if one needs to handle big data sets. A special tagname '*' can be used to match any name. If this function is called in SCALAR context, it returns the number of elements found. =item getChildrenByTagNameNS @nodes = $node->getChildrenByTagNameNS($nsURI,$tagname); Namespace version of C<<<<<< getChildrenByTagName >>>>>>. A special nsURI '*' matches any namespace URI, in which case the function behaves just like C<<<<<< getChildrenByLocalName >>>>>>. If this function is called in SCALAR context, it returns the number of elements found. =item getChildrenByLocalName @nodes = $node->getChildrenByLocalName($localname); The function gives direct access to all child elements of the current node with a given local name. It makes things a lot easier if one needs to handle big data sets. A special C<<<<<< localname >>>>>> '*' can be used to match any local name. If this function is called in SCALAR context, it returns the number of elements found. =item getElementsByTagName @nodes = $node->getElementsByTagName($tagname); This function is part of the spec. It fetches all descendants of a node with a given tagname, where C<<<<<< tagname >>>>>> is a qualified name, that is, in case of namespace usage it may consist of a prefix and local name. A special C<<<<<< tagname >>>>>> '*' can be used to match any tag name. In SCALAR context this function returns an L<<<<<< XML::LibXML::NodeList >>>>>> object. =item getElementsByTagNameNS @nodes = $node->getElementsByTagNameNS($nsURI,$localname); Namespace version of C<<<<<< getElementsByTagName >>>>>> as found in the DOM spec. A special C<<<<<< localname >>>>>> '*' can be used to match any local name and C<<<<<< nsURI >>>>>> '*' can be used to match any namespace URI. In SCALAR context this function returns an L<<<<<< XML::LibXML::NodeList >>>>>> object. =item getElementsByLocalName @nodes = $node->getElementsByLocalName($localname); This function is not found in the DOM specification. It is a mix of getElementsByTagName and getElementsByTagNameNS. It will fetch all tags matching the given local-name. This allows one to select tags with the same local name across namespace borders. In SCALAR context this function returns an L<<<<<< XML::LibXML::NodeList >>>>>> object. =item appendWellBalancedChunk $node->appendWellBalancedChunk( $chunk ); Sometimes it is necessary to append a string coded XML Tree to a node. I<<<<<< appendWellBalancedChunk >>>>>> will do the trick for you. But this is only done if the String is C<<<<<< well-balanced >>>>>>. I<<<<<< Note that appendWellBalancedChunk() is only left for compatibility reasons >>>>>>. Implicitly it uses my $fragment = $parser->parse_balanced_chunk( $chunk ); $node->appendChild( $fragment ); This form is more explicit and makes it easier to control the flow of a script. =item appendText $node->appendText( $PCDATA ); alias for appendTextNode(). =item appendTextNode $node->appendTextNode( $PCDATA ); This wrapper function lets you add a string directly to an element node. =item appendTextChild $node->appendTextChild( $childname , $PCDATA ); Somewhat similar with C<<<<<< appendTextNode >>>>>>: It lets you set an Element, that contains only a C<<<<<< text node >>>>>> directly by specifying the name and the text content. =item setNamespace $node->setNamespace( $nsURI , $nsPrefix, $activate ); setNamespace() allows one to apply a namespace to an element. The function takes three parameters: 1. the namespace URI, which is required and the two optional values prefix, which is the namespace prefix, as it should be used in child elements or attributes as well as the additional activate parameter. If prefix is not given, undefined or empty, this function tries to create a declaration of the default namespace. The activate parameter is most useful: If this parameter is set to FALSE (0), a new namespace declaration is simply added to the element while the element's namespace itself is not altered. Nevertheless, activate is set to TRUE (1) on default. In this case the namespace is used as the node's effective namespace. This means the namespace prefix is added to the node name and if there was a namespace already active for the node, it will be replaced (but its declaration is not removed from the document). A new namespace declaration is only created if necessary (that is, if the element is already in the scope of a namespace declaration associating the prefix with the namespace URI, then this declaration is reused). The following example may clarify this: my $e1 = $doc->createElement("bar"); $e1->setNamespace("http://foobar.org", "foo") results while my $e2 = $doc->createElement("bar"); $e2->setNamespace("http://foobar.org", "foo",0) results only By using $activate == 0 it is possible to create multiple namespace declarations on a single element. The function fails if it is required to create a declaration associating the prefix with the namespace URI but the element already carries a declaration with the same prefix but different namespace URI. =item setNamespaceDeclURI $node->setNamespaceDeclURI( $nsPrefix, $newURI ); EXPERIMENTAL IN 1.61 ! This function manipulates directly with an existing namespace declaration on an element. It takes two parameters: the prefix by which it looks up the namespace declaration and a new namespace URI which replaces its previous value. It returns 1 if the namespace declaration was found and changed, 0 otherwise. All elements and attributes (even those previously unbound from the document) for which the namespace declaration determines their namespace belong to the new namespace after the change. If the new URI is undef or empty, the nodes have no namespace and no prefix after the change. Namespace declarations once nulled in this way do not further appear in the serialized output (but do remain in the document for internal integrity of libxml2 data structures). This function is NOT part of any DOM API. =item setNamespaceDeclPrefix $node->setNamespaceDeclPrefix( $oldPrefix, $newPrefix ); EXPERIMENTAL IN 1.61 ! This function manipulates directly with an existing namespace declaration on an element. It takes two parameters: the old prefix by which it looks up the namespace declaration and a new prefix which is to replace the old one. The function dies with an error if the element is in the scope of another declaration whose prefix equals to the new prefix, or if the change should result in a declaration with a non-empty prefix but empty namespace URI. Otherwise, it returns 1 if the namespace declaration was found and changed and 0 if not found. All elements and attributes (even those previously unbound from the document) for which the namespace declaration determines their namespace change their prefix to the new value. If the new prefix is undef or empty, the namespace declaration becomes a declaration of a default namespace. The corresponding nodes drop their namespace prefix (but remain in the, now default, namespace). In this case the function fails, if the containing element is in the scope of another default namespace declaration. This function is NOT part of any DOM API. =back =head1 OVERLOADING XML::LibXML::Element overloads hash dereferencing to provide access to the element's attributes. For non-namespaced attributes, the attribute name is the hash key, and the attribute value is the hash value. For namespaced attributes, the hash key is qualified with the namespace URI, using Clark notation. Perl's "tied hash" feature is used, which means that the hash gives you read-write access to the element's attributes. For more information, see L<<<<<< XML::LibXML::AttributeHash >>>>>> =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]0Ŧ LibXML/Common.pmnu6$#-------------------------------------------------------------------------# # $Id: Common.pm,v 1.5 2003/02/27 18:32:59 phish108 Exp $ # # # This is free software, you may use it and distribute it under the same terms as # Perl itself. # # Copyright 2001-2003 AxKit.com Ltd., 2002-2006 Christian Glahn, 2006-2009 Petr Pajas # # #-------------------------------------------------------------------------# package XML::LibXML::Common; #-------------------------------------------------------------------------# # global blur # #-------------------------------------------------------------------------# use strict; use warnings; require Exporter; our @ISA = qw(Exporter); our $VERSION = "2.0213"; # VERSION TEMPLATE: DO NOT CHANGE use XML::LibXML qw(:libxml); #-------------------------------------------------------------------------# # export information # #-------------------------------------------------------------------------# our %EXPORT_TAGS = ( all => [qw( ELEMENT_NODE ATTRIBUTE_NODE TEXT_NODE CDATA_SECTION_NODE ENTITY_REFERENCE_NODE ENTITY_NODE PI_NODE PROCESSING_INSTRUCTION_NODE COMMENT_NODE DOCUMENT_NODE DOCUMENT_TYPE_NODE DOCUMENT_FRAG_NODE DOCUMENT_FRAGMENT_NODE NOTATION_NODE HTML_DOCUMENT_NODE DTD_NODE ELEMENT_DECLARATION ATTRIBUTE_DECLARATION ENTITY_DECLARATION NAMESPACE_DECLARATION XINCLUDE_END XINCLUDE_START encodeToUTF8 decodeFromUTF8 )], w3c => [qw( ELEMENT_NODE ATTRIBUTE_NODE TEXT_NODE CDATA_SECTION_NODE ENTITY_REFERENCE_NODE ENTITY_NODE PI_NODE PROCESSING_INSTRUCTION_NODE COMMENT_NODE DOCUMENT_NODE DOCUMENT_TYPE_NODE DOCUMENT_FRAG_NODE DOCUMENT_FRAGMENT_NODE NOTATION_NODE HTML_DOCUMENT_NODE DTD_NODE ELEMENT_DECLARATION ATTRIBUTE_DECLARATION ENTITY_DECLARATION NAMESPACE_DECLARATION XINCLUDE_END XINCLUDE_START )], libxml => [qw( XML_ELEMENT_NODE XML_ATTRIBUTE_NODE XML_TEXT_NODE XML_CDATA_SECTION_NODE XML_ENTITY_REF_NODE XML_ENTITY_NODE XML_PI_NODE XML_COMMENT_NODE XML_DOCUMENT_NODE XML_DOCUMENT_TYPE_NODE XML_DOCUMENT_FRAG_NODE XML_NOTATION_NODE XML_HTML_DOCUMENT_NODE XML_DTD_NODE XML_ELEMENT_DECL XML_ATTRIBUTE_DECL XML_ENTITY_DECL XML_NAMESPACE_DECL XML_XINCLUDE_END XML_XINCLUDE_START )], gdome => [qw( GDOME_ELEMENT_NODE GDOME_ATTRIBUTE_NODE GDOME_TEXT_NODE GDOME_CDATA_SECTION_NODE GDOME_ENTITY_REF_NODE GDOME_ENTITY_NODE GDOME_PI_NODE GDOME_COMMENT_NODE GDOME_DOCUMENT_NODE GDOME_DOCUMENT_TYPE_NODE GDOME_DOCUMENT_FRAG_NODE GDOME_NOTATION_NODE GDOME_HTML_DOCUMENT_NODE GDOME_DTD_NODE GDOME_ELEMENT_DECL GDOME_ATTRIBUTE_DECL GDOME_ENTITY_DECL GDOME_NAMESPACE_DECL GDOME_XINCLUDE_END GDOME_XINCLUDE_START )], encoding => [qw( encodeToUTF8 decodeFromUTF8 )], ); our @EXPORT_OK = ( @{$EXPORT_TAGS{encoding}}, @{$EXPORT_TAGS{w3c}}, @{$EXPORT_TAGS{libxml}}, @{$EXPORT_TAGS{gdome}}, ); our @EXPORT = ( @{$EXPORT_TAGS{encoding}}, @{$EXPORT_TAGS{w3c}}, ); #-------------------------------------------------------------------------# # W3 conform node types # #-------------------------------------------------------------------------# use constant ELEMENT_NODE => 1; use constant ATTRIBUTE_NODE => 2; use constant TEXT_NODE => 3; use constant CDATA_SECTION_NODE => 4; use constant ENTITY_REFERENCE_NODE => 5; use constant ENTITY_NODE => 6; use constant PROCESSING_INSTRUCTION_NODE => 7; use constant COMMENT_NODE => 8; use constant DOCUMENT_NODE => 9; use constant DOCUMENT_TYPE_NODE => 10; use constant DOCUMENT_FRAGMENT_NODE => 11; use constant NOTATION_NODE => 12; use constant HTML_DOCUMENT_NODE => 13; use constant DTD_NODE => 14; use constant ELEMENT_DECLARATION => 15; use constant ATTRIBUTE_DECLARATION => 16; use constant ENTITY_DECLARATION => 17; use constant NAMESPACE_DECLARATION => 18; #-------------------------------------------------------------------------# # some extras for the W3 spec #-------------------------------------------------------------------------# use constant PI_NODE => 7; use constant DOCUMENT_FRAG_NODE => 11; use constant XINCLUDE_END => 19; use constant XINCLUDE_START => 20; #-------------------------------------------------------------------------# # libgdome compat names # #-------------------------------------------------------------------------# use constant GDOME_ELEMENT_NODE => 1; use constant GDOME_ATTRIBUTE_NODE => 2; use constant GDOME_TEXT_NODE => 3; use constant GDOME_CDATA_SECTION_NODE => 4; use constant GDOME_ENTITY_REF_NODE => 5; use constant GDOME_ENTITY_NODE => 6; use constant GDOME_PI_NODE => 7; use constant GDOME_COMMENT_NODE => 8; use constant GDOME_DOCUMENT_NODE => 9; use constant GDOME_DOCUMENT_TYPE_NODE => 10; use constant GDOME_DOCUMENT_FRAG_NODE => 11; use constant GDOME_NOTATION_NODE => 12; use constant GDOME_HTML_DOCUMENT_NODE => 13; use constant GDOME_DTD_NODE => 14; use constant GDOME_ELEMENT_DECL => 15; use constant GDOME_ATTRIBUTE_DECL => 16; use constant GDOME_ENTITY_DECL => 17; use constant GDOME_NAMESPACE_DECL => 18; use constant GDOME_XINCLUDE_START => 19; use constant GDOME_XINCLUDE_END => 20; 1; #-------------------------------------------------------------------------# __END__ PKM]LSYLibXML/SAX/Builder.podnu6$=head1 NAME XML::LibXML::SAX::Builder - Building DOM trees from SAX events. =head1 SYNOPSIS use XML::LibXML::SAX::Builder; my $builder = XML::LibXML::SAX::Builder->new(); my $gen = XML::Generator::DBI->new(Handler => $builder, dbh => $dbh); $gen->execute("SELECT * FROM Users"); my $doc = $builder->result(); =head1 DESCRIPTION This is a SAX handler that generates a DOM tree from SAX events. Usage is as above. Input is accepted from any SAX1 or SAX2 event generator. Building DOM trees from SAX events is quite easy with XML::LibXML::SAX::Builder. The class is designed as a SAX2 final handler not as a filter! Since SAX is strictly stream oriented, you should not expect anything to return from a generator. Instead you have to ask the builder instance directly to get the document built. XML::LibXML::SAX::Builder's result() function holds the document generated from the last SAX stream. =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]LibXML/SAX/Parser.pmnu6$# $Id$ # # This is free software, you may use it and distribute it under the same terms as # Perl itself. # # Copyright 2001-2003 AxKit.com Ltd., 2002-2006 Christian Glahn, 2006-2009 Petr Pajas # # package XML::LibXML::SAX::Parser; use strict; use warnings; use XML::LibXML; use XML::LibXML::Common qw(:libxml); use XML::SAX::Base; use XML::SAX::DocumentLocator; our $VERSION = "2.0213"; # VERSION TEMPLATE: DO NOT CHANGE our @ISA = ('XML::SAX::Base'); sub CLONE_SKIP { return $XML::LibXML::__threads_shared ? 0 : 1; } sub _parse_characterstream { my ($self, $fh, $options) = @_; die "parsing a characterstream is not supported at this time"; } sub _parse_bytestream { my ($self, $fh, $options) = @_; my $parser = XML::LibXML->new(); my $doc = exists($options->{Source}{SystemId}) ? $parser->parse_fh($fh, $options->{Source}{SystemId}) : $parser->parse_fh($fh); $self->generate($doc); } sub _parse_string { my ($self, $str, $options) = @_; my $parser = XML::LibXML->new(); my $doc = exists($options->{Source}{SystemId}) ? $parser->parse_string($str, $options->{Source}{SystemId}) : $parser->parse_string($str); $self->generate($doc); } sub _parse_systemid { my ($self, $sysid, $options) = @_; my $parser = XML::LibXML->new(); my $doc = $parser->parse_file($sysid); $self->generate($doc); } sub generate { my $self = shift; my ($node) = @_; my $doc = $node->ownerDocument(); { # precompute some DocumentLocator values my %locator = ( PublicId => undef, SystemId => undef, Encoding => undef, XMLVersion => undef, ); my $dtd = defined $doc ? $doc->externalSubset() : undef; if (defined $dtd) { $locator{PublicId} = $dtd->publicId(); $locator{SystemId} = $dtd->systemId(); } if (defined $doc) { $locator{Encoding} = $doc->encoding(); $locator{XMLVersion} = $doc->version(); } $self->set_document_locator( XML::SAX::DocumentLocator->new( sub { $locator{PublicId} }, sub { $locator{SystemId} }, sub { defined($self->{current_node}) ? $self->{current_node}->line_number() : undef }, sub { 1 }, sub { $locator{Encoding} }, sub { $locator{XMLVersion} }, ), ); } if ( $node->nodeType() == XML_DOCUMENT_NODE || $node->nodeType == XML_HTML_DOCUMENT_NODE ) { $self->start_document({}); $self->xml_decl({Version => $node->getVersion, Encoding => $node->getEncoding}); $self->process_node($node); $self->end_document({}); } } sub process_node { my ($self, $node) = @_; local $self->{current_node} = $node; my $node_type = $node->nodeType(); if ($node_type == XML_COMMENT_NODE) { $self->comment( { Data => $node->getData } ); } elsif ($node_type == XML_TEXT_NODE || $node_type == XML_CDATA_SECTION_NODE) { # warn($node->getData . "\n"); $self->characters( { Data => $node->nodeValue } ); } elsif ($node_type == XML_ELEMENT_NODE) { # warn("<" . $node->getName . ">\n"); $self->process_element($node); # warn("getName . ">\n"); } elsif ($node_type == XML_ENTITY_REF_NODE) { foreach my $kid ($node->childNodes) { # warn("child of entity ref: " . $kid->getType() . " called: " . $kid->getName . "\n"); $self->process_node($kid); } } elsif ($node_type == XML_DOCUMENT_NODE || $node_type == XML_HTML_DOCUMENT_NODE || $node_type == XML_DOCUMENT_FRAG_NODE) { # sometimes it is just useful to generate SAX events from # a document fragment (very good with filters). foreach my $kid ($node->childNodes) { $self->process_node($kid); } } elsif ($node_type == XML_PI_NODE) { $self->processing_instruction( { Target => $node->getName, Data => $node->getData } ); } elsif ($node_type == XML_COMMENT_NODE) { $self->comment( { Data => $node->getData } ); } elsif ( $node_type == XML_XINCLUDE_START || $node_type == XML_XINCLUDE_END ) { # ignore! # i may want to handle this one day, dunno yet } elsif ($node_type == XML_DTD_NODE ) { # ignore! # i will support DTDs, but had no time yet. } else { # warn("unsupported node type: $node_type"); } } sub process_element { my ($self, $element) = @_; my $attribs = {}; my @ns_maps = $element->getNamespaces; foreach my $ns (@ns_maps) { $self->start_prefix_mapping( { NamespaceURI => $ns->href, Prefix => ( defined $ns->localname ? $ns->localname : ''), } ); } foreach my $attr ($element->attributes) { my $key; # warn("Attr: $attr -> ", $attr->getName, " = ", $attr->getData, "\n"); # this isa dump thing... if ($attr->isa('XML::LibXML::Namespace')) { # TODO This needs fixing modulo agreeing on what # is the right thing to do here. unless ( defined $attr->name ) { ## It's an atter like "xmlns='foo'" $attribs->{"{}xmlns"} = { Name => "xmlns", LocalName => "xmlns", Prefix => "", Value => $attr->href, NamespaceURI => "", }; } else { my $prefix = "xmlns"; my $localname = $attr->localname; my $key = "{http://www.w3.org/2000/xmlns/}"; my $name = "xmlns"; if ( defined $localname ) { $key .= $localname; $name.= ":".$localname; } $attribs->{$key} = { Name => $name, Value => $attr->href, NamespaceURI => "http://www.w3.org/2000/xmlns/", Prefix => $prefix, LocalName => $localname, }; } } else { my $ns = $attr->namespaceURI; $ns = '' unless defined $ns; $key = "{$ns}".$attr->localname; ## Not sure why, but $attr->name is coming through stripped ## of its prefix, so we need to hand-assemble a real name. my $name = $attr->name; $name = "" unless defined $name; my $prefix = $attr->prefix; $prefix = "" unless defined $prefix; $name = "$prefix:$name" if index( $name, ":" ) < 0 && length $prefix; $attribs->{$key} = { Name => $name, Value => $attr->value, NamespaceURI => $ns, Prefix => $prefix, LocalName => $attr->localname, }; } # use Data::Dumper; # warn("Attr made: ", Dumper($attribs->{$key}), "\n"); } my $node = { Name => $element->nodeName, Attributes => $attribs, NamespaceURI => $element->namespaceURI, Prefix => $element->prefix || "", LocalName => $element->localname, }; $self->start_element($node); foreach my $child ($element->childNodes) { $self->process_node($child); } my $end_node = { %$node }; delete $end_node->{Attributes}; $self->end_element($end_node); foreach my $ns (@ns_maps) { $self->end_prefix_mapping( { NamespaceURI => $ns->href, Prefix => ( defined $ns->localname ? $ns->localname : ''), } ); } } 1; __END__ PKM]mLibXML/SAX/Generator.pmnu6$# $Id: Generator.pm 772 2009-01-23 21:42:09Z pajas # # This is free software, you may use it and distribute it under the same terms as # Perl itself. # # Copyright 2001-2003 AxKit.com Ltd., 2002-2006 Christian Glahn, 2006-2009 Petr Pajas # # package XML::LibXML::SAX::Generator; use strict; use warnings; use XML::LibXML; our $VERSION = "2.0213"; # VERSION TEMPLATE: DO NOT CHANGE sub CLONE_SKIP { return $XML::LibXML::__threads_shared ? 0 : 1; } warn("This class (", __PACKAGE__, ") is deprecated!"); sub new { my $class = shift; unshift @_, 'Handler' unless @_ != 1; my %p = @_; return bless \%p, $class; } sub generate { my $self = shift; my ($node) = @_; my $document = { Parent => undef }; $self->{Handler}->start_document($document); process_node($self->{Handler}, $node); $self->{Handler}->end_document($document); } sub process_node { my ($handler, $node) = @_; my $node_type = $node->getType(); if ($node_type == XML_COMMENT_NODE) { $handler->comment( { Data => $node->getData } ); } elsif ($node_type == XML_TEXT_NODE || $node_type == XML_CDATA_SECTION_NODE) { # warn($node->getData . "\n"); $handler->characters( { Data => $node->getData } ); } elsif ($node_type == XML_ELEMENT_NODE) { # warn("<" . $node->getName . ">\n"); process_element($handler, $node); # warn("getName . ">\n"); } elsif ($node_type == XML_ENTITY_REF_NODE) { foreach my $kid ($node->getChildnodes) { # warn("child of entity ref: " . $kid->getType() . " called: " . $kid->getName . "\n"); process_node($handler, $kid); } } elsif ($node_type == XML_DOCUMENT_NODE) { # just get root element. Ignore other cruft. foreach my $kid ($node->getChildnodes) { if ($kid->getType() == XML_ELEMENT_NODE) { process_element($handler, $kid); last; } } } else { warn("unknown node type: $node_type"); } } sub process_element { my ($handler, $element) = @_; my @attr; foreach my $attr ($element->getAttributes) { push @attr, XML::LibXML::SAX::AttributeNode->new( Name => $attr->getName, Value => $attr->getData, NamespaceURI => $attr->getNamespaceURI, Prefix => $attr->getPrefix, LocalName => $attr->getLocalName, ); } my $node = { Name => $element->getName, Attributes => { map { $_->{Name} => $_ } @attr }, NamespaceURI => $element->getNamespaceURI, Prefix => $element->getPrefix, LocalName => $element->getLocalName, }; $handler->start_element($node); foreach my $child ($element->getChildnodes) { process_node($handler, $child); } $handler->end_element($node); } package XML::LibXML::SAX::AttributeNode; use overload '""' => "stringify"; sub new { my $class = shift; my %p = @_; return bless \%p, $class; } sub stringify { my $self = shift; return $self->{Value}; } 1; __END__ =head1 NAME XML::LibXML::SAX::Generator - Generate SAX events from a LibXML tree =head1 SYNOPSIS my $handler = MySAXHandler->new(); my $generator = XML::LibXML::SAX::Generator->new(Handler => $handler); my $dom = XML::LibXML->new->parse_file("foo.xml"); $generator->generate($dom); =head1 DESCRIPTION THIS CLASS IS DEPRECATED! Use XML::LibXML::SAX::Parser instead! This helper class allows you to generate SAX events from any XML::LibXML node, and all it's sub-nodes. This basically gives you interop from XML::LibXML to other modules that may implement SAX. It uses SAX2 style, but should be compatible with anything SAX1, by use of stringification overloading. There is nothing to really know about, beyond the synopsis above, and a general knowledge of how to use SAX, which is beyond the scope here. =cut PKM]"h LibXML/SAX/Builder.pmnu6$# $Id$ # # This is free software, you may use it and distribute it under the same terms as # Perl itself. # # Copyright 2001-2003 AxKit.com Ltd., 2002-2006 Christian Glahn, 2006-2009 Petr Pajas # # package XML::LibXML::SAX::Builder; use strict; use warnings; use XML::LibXML; use XML::NamespaceSupport; sub CLONE_SKIP { return $XML::LibXML::__threads_shared ? 0 : 1; } our $VERSION = "2.0213"; # VERSION TEMPLATE: DO NOT CHANGE sub new { my $class = shift; return bless {@_}, $class; } sub result { $_[0]->{LAST_DOM}; } sub done { my ($self) = @_; my $dom = $self->{DOM}; $dom = $self->{Parent} unless defined $dom; # this is for parsing document chunks delete $self->{NamespaceStack}; delete $self->{Parent}; delete $self->{DOM}; $self->{LAST_DOM} = $dom; return $dom; } sub set_document_locator { } sub start_dtd { my ($self, $dtd) = @_; if (defined $dtd->{Name} and (defined $dtd->{SystemId} or defined $dtd->{PublicId})) { $self->{DOM}->createExternalSubset($dtd->{Name},$dtd->{PublicId},$dtd->{SystemId}); } } sub end_dtd { } sub start_document { my ($self, $doc) = @_; $self->{DOM} = XML::LibXML::Document->createDocument(); if ( defined $self->{Encoding} ) { $self->xml_decl({Version => ($self->{Version} || '1.0') , Encoding => $self->{Encoding}}); } $self->{NamespaceStack} = XML::NamespaceSupport->new; $self->{NamespaceStack}->push_context; $self->{Parent} = undef; return (); } sub xml_decl { my $self = shift; my $decl = shift; if ( defined $decl->{Version} ) { $self->{DOM}->setVersion( $decl->{Version} ); } if ( defined $decl->{Encoding} ) { $self->{DOM}->setEncoding( $decl->{Encoding} ); } return (); } sub end_document { my ($self, $doc) = @_; my $d = $self->done(); return $d; } sub start_prefix_mapping { my $self = shift; my $ns = shift; unless ( defined $self->{DOM} or defined $self->{Parent} ) { $self->{Parent} = XML::LibXML::DocumentFragment->new(); $self->{NamespaceStack} = XML::NamespaceSupport->new; $self->{NamespaceStack}->push_context; } $self->{USENAMESPACESTACK} = 1; $self->{NamespaceStack}->declare_prefix( $ns->{Prefix}, $ns->{NamespaceURI} ); return (); } sub end_prefix_mapping { my $self = shift; my $ns = shift; $self->{NamespaceStack}->undeclare_prefix( $ns->{Prefix} ); return (); } sub start_element { my ($self, $el) = @_; my $node; unless ( defined $self->{DOM} or defined $self->{Parent} ) { $self->{Parent} = XML::LibXML::DocumentFragment->new(); $self->{NamespaceStack} = XML::NamespaceSupport->new; $self->{NamespaceStack}->push_context; } if ( defined $self->{Parent} ) { $el->{NamespaceURI} ||= ""; $node = $self->{Parent}->addNewChild( $el->{NamespaceURI}, $el->{Name} ); } else { if ($el->{NamespaceURI}) { if ( defined $self->{DOM} ) { $node = $self->{DOM}->createRawElementNS($el->{NamespaceURI}, $el->{Name}); } else { $node = XML::LibXML::Element->new( $el->{Name} ); $node->setNamespace( $el->{NamespaceURI}, $el->{Prefix} , 1 ); } } else { if ( defined $self->{DOM} ) { $node = $self->{DOM}->createRawElement($el->{Name}); } else { $node = XML::LibXML::Element->new( $el->{Name} ); } } $self->{DOM}->setDocumentElement($node); } # build namespaces my $skip_ns= 0; foreach my $p ( $self->{NamespaceStack}->get_declared_prefixes() ) { $skip_ns= 1; my $uri = $self->{NamespaceStack}->get_uri($p); my $nodeflag = 0; if ( defined $uri and defined $el->{NamespaceURI} and $uri eq $el->{NamespaceURI} ) { # $nodeflag = 1; next; } $node->setNamespace($uri, $p, 0 ); } $self->{Parent} = $node; $self->{NamespaceStack}->push_context; # do attributes foreach my $key (keys %{$el->{Attributes}}) { my $attr = $el->{Attributes}->{$key}; if (ref($attr)) { # catch broken name/value pairs next unless $attr->{Name} ; next if $self->{USENAMESPACESTACK} and ( $attr->{Name} eq "xmlns" or ( defined $attr->{Prefix} and $attr->{Prefix} eq "xmlns" ) ); if ( defined $attr->{Prefix} and $attr->{Prefix} eq "xmlns" and $skip_ns == 0 ) { # ok, the generator does not set namespaces correctly! my $uri = $attr->{Value}; $node->setNamespace($uri, $attr->{LocalName}, $uri eq $el->{NamespaceURI} ? 1 : 0 ); } else { $node->setAttributeNS($attr->{NamespaceURI} || "", $attr->{Name}, $attr->{Value}); } } else { $node->setAttribute($key => $attr); } } return (); } sub end_element { my ($self, $el) = @_; return unless $self->{Parent}; $self->{NamespaceStack}->pop_context; $self->{Parent} = $self->{Parent}->parentNode(); return (); } sub start_cdata { my $self = shift; $self->{IN_CDATA} = 1; return (); } sub end_cdata { my $self = shift; $self->{IN_CDATA} = 0; return (); } sub characters { my ($self, $chars) = @_; if ( not defined $self->{DOM} and not defined $self->{Parent} ) { $self->{Parent} = XML::LibXML::DocumentFragment->new(); $self->{NamespaceStack} = XML::NamespaceSupport->new; $self->{NamespaceStack}->push_context; } return unless $self->{Parent}; my $node; unless ( defined $chars and defined $chars->{Data} ) { return; } if ( defined $self->{DOM} ) { if ( defined $self->{IN_CDATA} and $self->{IN_CDATA} == 1 ) { $node = $self->{DOM}->createCDATASection($chars->{Data}); } else { $node = $self->{Parent}->appendText($chars->{Data}); return; } } elsif ( defined $self->{IN_CDATA} and $self->{IN_CDATA} == 1 ) { $node = XML::LibXML::CDATASection->new($chars->{Data}); } else { $node = XML::LibXML::Text->new($chars->{Data}); } $self->{Parent}->addChild($node); return (); } sub comment { my ($self, $chars) = @_; my $comment; if ( not defined $self->{DOM} and not defined $self->{Parent} ) { $self->{Parent} = XML::LibXML::DocumentFragment->new(); $self->{NamespaceStack} = XML::NamespaceSupport->new; $self->{NamespaceStack}->push_context; } unless ( defined $chars and defined $chars->{Data} ) { return; } if ( defined $self->{DOM} ) { $comment = $self->{DOM}->createComment( $chars->{Data} ); } else { $comment = XML::LibXML::Comment->new( $chars->{Data} ); } if ( defined $self->{Parent} ) { $self->{Parent}->addChild($comment); } else { $self->{DOM}->addChild($comment); } return (); } sub processing_instruction { my ( $self, $pi ) = @_; my $PI; return unless defined $self->{DOM}; $PI = $self->{DOM}->createPI( $pi->{Target}, $pi->{Data} ); if ( defined $self->{Parent} ) { $self->{Parent}->addChild( $PI ); } else { $self->{DOM}->addChild( $PI ); } return (); } sub warning { my $self = shift; my $error = shift; # fill $@ but do not die seriously eval { $error->throw; }; } sub error { my $self = shift; my $error = shift; delete $self->{NamespaceStack}; delete $self->{Parent}; delete $self->{DOM}; $error->throw; } sub fatal_error { my $self = shift; my $error = shift; delete $self->{NamespaceStack}; delete $self->{Parent}; delete $self->{DOM}; $error->throw; } 1; __END__ PKM]&$LibXML/Attr.podnu6$=head1 NAME XML::LibXML::Attr - XML::LibXML Attribute Class =head1 SYNOPSIS use XML::LibXML; # Only methods specific to Attribute nodes are listed here, # see the XML::LibXML::Node manpage for other methods $attr = XML::LibXML::Attr->new($name [,$value]); $string = $attr->getValue(); $string = $attr->value; $attr->setValue( $string ); $node = $attr->getOwnerElement(); $attr->setNamespace($nsURI, $prefix); $bool = $attr->isId; $string = $attr->serializeContent; =head1 DESCRIPTION This is the interface to handle Attributes like ordinary nodes. The naming of the class relies on the W3C DOM documentation. =head1 METHODS The class inherits from L<<<<<< XML::LibXML::Node >>>>>>. The documentation for Inherited methods is not listed here. Many functions listed here are extensively documented in the DOM Level 3 specification (L<<<<<< http://www.w3.org/TR/DOM-Level-3-Core/ >>>>>>). Please refer to the specification for extensive documentation. =over 4 =item new $attr = XML::LibXML::Attr->new($name [,$value]); Class constructor. If you need to work with ISO encoded strings, you should I<<<<<< always >>>>>> use the C<<<<<< createAttribute >>>>>> of L<<<<<< XML::LibXML::Document >>>>>>. =item getValue $string = $attr->getValue(); Returns the value stored for the attribute. If undef is returned, the attribute has no value, which is different of being C<<<<<< not specified >>>>>>. =item value $string = $attr->value; Alias for I<<<<<< getValue() >>>>>> =item setValue $attr->setValue( $string ); This is needed to set a new attribute value. If ISO encoded strings are passed as parameter, the node has to be bound to a document, otherwise the encoding might be done incorrectly. =item getOwnerElement $node = $attr->getOwnerElement(); returns the node the attribute belongs to. If the attribute is not bound to a node, undef will be returned. Overwriting the underlying implementation, the I<<<<<< parentNode >>>>>> function will return undef, instead of the owner element. =item setNamespace $attr->setNamespace($nsURI, $prefix); This function tries to bound the attribute to a given namespace. If C<<<<<< $nsURI >>>>>> is undefined or empty, the function discards any previous association of the attribute with a namespace. If the namespace was not previously declared in the context of the attribute, this function will fail. In this case you may wish to call setNamespace() on the ownerElement. If the namespace URI is non-empty and declared in the context of the attribute, but only with a different (non-empty) prefix, then the attribute is still bound to the namespace but gets a different prefix than C<<<<<< $prefix >>>>>>. The function also fails if the prefix is empty but the namespace URI is not (because unprefixed attributes should by definition belong to no namespace). This function returns 1 on success, 0 otherwise. =item isId $bool = $attr->isId; Determine whether an attribute is of type ID. For documents with a DTD, this information is only available if DTD loading/validation has been requested. For HTML documents parsed with the HTML parser ID detection is done automatically. In XML documents, all "xml:id" attributes are considered to be of type ID. =item serializeContent($docencoding) $string = $attr->serializeContent; This function is not part of DOM API. It returns attribute content in the form in which it serializes into XML, that is with all meta-characters properly quoted and with raw entity references (except for entities expanded during parse time). Setting the optional $docencoding flag to 1 enforces document encoding for the output string (which is then passed to Perl as a byte string). Otherwise the string is passed to Perl as (UTF-8 encoded) characters. =back =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]Cz,LibXML/Literal.pmnu6$# $Id$ # # This is free software, you may use it and distribute it under the same terms as # Perl itself. # # Copyright 2001-2003 AxKit.com Ltd., 2002-2006 Christian Glahn, 2006-2009 Petr Pajas # # package XML::LibXML::Literal; use XML::LibXML::Boolean; use XML::LibXML::Number; use strict; use warnings; our $VERSION = "2.0213"; # VERSION TEMPLATE: DO NOT CHANGE use overload '""' => \&value, 'cmp' => \&cmp; sub new { my $class = shift; my ($string) = @_; # $string =~ s/"/"/g; # $string =~ s/'/'/g; bless \$string, $class; } sub as_string { my $self = shift; my $string = $$self; $string =~ s/'/'/g; return "'$string'"; } sub as_xml { my $self = shift; my $string = $$self; return "$string\n"; } sub value { my $self = shift; $$self; } sub cmp { my $self = shift; my ($cmp, $swap) = @_; if ($swap) { return $cmp cmp $$self; } return $$self cmp $cmp; } sub evaluate { my $self = shift; $self; } sub to_boolean { my $self = shift; return (length($$self) > 0) ? XML::LibXML::Boolean->True : XML::LibXML::Boolean->False; } sub to_number { return XML::LibXML::Number->new($_[0]->value); } sub to_literal { return $_[0]; } sub string_value { return $_[0]->value; } 1; __END__ =head1 NAME XML::LibXML::Literal - Simple string values. =head1 DESCRIPTION In XPath terms a Literal is what we know as a string. =head1 API =head2 new($string) Create a new Literal object with the value in $string. Note that " and ' will be converted to " and ' respectively. That is not part of the XPath specification, but I consider it useful. Note though that you have to go to extraordinary lengths in an XML template file (be it XSLT or whatever) to make use of this: Which produces a Literal of: I'm feeling "sad" =head2 value() Also overloaded as stringification, simply returns the literal string value. =head2 cmp($literal) Returns the equivalent of perl's cmp operator against the given $literal. =cut PKM]ÚLibXML/Error.podnu6$=head1 NAME XML::LibXML::Error - Structured Errors =head1 SYNOPSIS eval { ... }; if (ref($@)) { # handle a structured error (XML::LibXML::Error object) } elsif ($@) { # error, but not an XML::LibXML::Error object } else { # no error } $XML::LibXML::Error::WARNINGS=1; $message = $@->as_string(); print $@->dump(); $error_domain = $@->domain(); $error_code = $@->code(); $error_message = $@->message(); $error_level = $@->level(); $filename = $@->file(); $line = $@->line(); $nodename = $@->nodename(); $error_str1 = $@->str1(); $error_str2 = $@->str2(); $error_str3 = $@->str3(); $error_num1 = $@->num1(); $error_num2 = $@->num2(); $string = $@->context(); $offset = $@->column(); $previous_error = $@->_prev(); =head1 DESCRIPTION The XML::LibXML::Error class is a tiny frontend to I<<<<<< libxml2 >>>>>>'s structured error support. If XML::LibXML is compiled with structured error support, all errors reported by libxml2 are transformed to XML::LibXML::Error objects. These objects automatically serialize to the corresponding error messages when printed or used in a string operation, but as objects, can also be used to get a detailed and structured information about the error that occurred. Unlike most other XML::LibXML objects, XML::LibXML::Error doesn't wrap an underlying I<<<<<< libxml2 >>>>>> structure directly, but rather transforms it to a blessed Perl hash reference containing the individual fields of the structured error information as hash key-value pairs. Individual items (fields) of a structured error can either be obtained directly as $@->{field}, or using autoloaded methods such as $@->field() (where field is the field name). XML::LibXML::Error objects have the following fields: domain, code, level, file, line, nodename, message, str1, str2, str3, num1, num2, and _prev (some of them may be undefined). =over 4 =item $XML::LibXML::Error::WARNINGS $XML::LibXML::Error::WARNINGS=1; Traditionally, XML::LibXML was suppressing parser warnings by setting libxml2's global variable xmlGetWarningsDefaultValue to 0. Since 1.70 we do not change libxml2's global variables anymore; for backward compatibility, XML::LibXML suppresses warnings. This variable can be set to 1 to enable reporting of these warnings via Perl C<<<<<< warn >>>>>> and to 2 to report hem via C<<<<<< die >>>>>>. =item as_string $message = $@->as_string(); This function serializes an XML::LibXML::Error object to a string containing the full error message close to the message produced by I<<<<<< libxml2 >>>>>> default error handlers and tools like xmllint. This method is also used to overload "" operator on XML::LibXML::Error, so it is automatically called whenever XML::LibXML::Error object is treated as a string (e.g. in print $@). =item dump print $@->dump(); This function serializes an XML::LibXML::Error to a string displaying all fields of the error structure individually on separate lines of the form 'name' => 'value'. =item domain $error_domain = $@->domain(); Returns string containing information about what part of the library raised the error. Can be one of: "parser", "tree", "namespace", "validity", "HTML parser", "memory", "output", "I/O", "ftp", "http", "XInclude", "XPath", "xpointer", "regexp", "Schemas datatype", "Schemas parser", "Schemas validity", "Relax-NG parser", "Relax-NG validity", "Catalog", "C14N", "XSLT", "validity". =item code $error_code = $@->code(); Returns the actual libxml2 error code. The XML::LibXML::ErrNo module defines constants for individual error codes. Currently libxml2 uses over 480 different error codes. =item message $error_message = $@->message(); Returns a human-readable informative error message. =item level $error_level = $@->level(); Returns an integer value describing how consequent is the error. XML::LibXML::Error defines the following constants: =over 4 =item * XML_ERR_NONE = 0 =item * XML_ERR_WARNING = 1 : A simple warning. =item * XML_ERR_ERROR = 2 : A recoverable error. =item * XML_ERR_FATAL = 3 : A fatal error. =back =item file $filename = $@->file(); Returns the filename of the file being processed while the error occurred. =item line $line = $@->line(); The line number, if available. =item nodename $nodename = $@->nodename(); Name of the node where error occurred, if available. When this field is non-empty, libxml2 actually returned a physical pointer to the specified node. Due to memory management issues, it is very difficult to implement a way to expose the pointer to the Perl level as a XML::LibXML::Node. For this reason, XML::LibXML::Error currently only exposes the name the node. =item str1 $error_str1 = $@->str1(); Error specific. Extra string information. =item str2 $error_str2 = $@->str2(); Error specific. Extra string information. =item str3 $error_str3 = $@->str3(); Error specific. Extra string information. =item num1 $error_num1 = $@->num1(); Error specific. Extra numeric information. =item num2 $error_num2 = $@->num2(); In recent libxml2 versions, this value contains a column number of the error or 0 if N/A. =item context $string = $@->context(); For parsing errors, this field contains about 80 characters of the XML near the place where the error occurred. The field C<<<<<< $@-Ecolumn() >>>>>> contains the corresponding offset. Where N/A, the field is undefined. =item column $offset = $@->column(); See C<<<<<< $@-Ecolumn() >>>>>> above. =item _prev $previous_error = $@->_prev(); This field can possibly hold a reference to another XML::LibXML::Error object representing an error which occurred just before this error. =back =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]h= LibXML/SAX.pmnu6$# $Id$ # # This is free software, you may use it and distribute it under the same terms as # Perl itself. # # Copyright 2001-2003 AxKit.com Ltd., 2002-2006 Christian Glahn, 2006-2009 Petr Pajas # # package XML::LibXML::SAX; use strict; use warnings; our $VERSION = "2.0213"; # VERSION TEMPLATE: DO NOT CHANGE use XML::LibXML; use XML::SAX::Base; use parent qw(XML::SAX::Base); use Carp; use IO::File; sub CLONE_SKIP { return $XML::LibXML::__threads_shared ? 0 : 1; } sub set_feature { my ($self, $feat, $val) = @_; if ($feat eq 'http://xmlns.perl.org/sax/join-character-data') { $self->{JOIN_CHARACTERS} = $val; return 1; } shift(@_); return $self->SUPER::set_feature(@_); } sub _parse_characterstream { my ( $self, $fh ) = @_; # this my catch the xml decl, so the parser won't get confused about # a possibly wrong encoding. croak( "not implemented yet" ); } # See: # https://rt.cpan.org/Public/Bug/Display.html?id=132759 sub _calc_new_XML_LibXML_parser_for_compatibility_with_XML_Simple_etc { return XML::LibXML->new( expand_entities => 1, ); } sub _parse_bytestream { my ( $self, $fh ) = @_; $self->{ParserOptions}{LibParser} = $self->_calc_new_XML_LibXML_parser_for_compatibility_with_XML_Simple_etc() unless defined $self->{ParserOptions}{LibParser}; $self->{ParserOptions}{ParseFunc} = \&XML::LibXML::parse_fh; $self->{ParserOptions}{ParseFuncParam} = $fh; $self->_parse; return $self->end_document({}); } sub _parse_string { my ( $self, $string ) = @_; $self->{ParserOptions}{LibParser} = $self->_calc_new_XML_LibXML_parser_for_compatibility_with_XML_Simple_etc() unless defined $self->{ParserOptions}{LibParser}; $self->{ParserOptions}{ParseFunc} = \&XML::LibXML::parse_string; $self->{ParserOptions}{ParseFuncParam} = $string; $self->_parse; return $self->end_document({}); } sub _parse_systemid { my $self = shift; $self->{ParserOptions}{LibParser} = $self->_calc_new_XML_LibXML_parser_for_compatibility_with_XML_Simple_etc() unless defined $self->{ParserOptions}{LibParser}; $self->{ParserOptions}{ParseFunc} = \&XML::LibXML::parse_file; $self->{ParserOptions}{ParseFuncParam} = shift; $self->_parse; return $self->end_document({}); } sub parse_chunk { my ( $self, $chunk ) = @_; $self->{ParserOptions}{LibParser} = $self->_calc_new_XML_LibXML_parser_for_compatibility_with_XML_Simple_etc() unless defined $self->{ParserOptions}{LibParser}; $self->{ParserOptions}{ParseFunc} = \&XML::LibXML::parse_xml_chunk; $self->{ParserOptions}{LibParser}->{IS_FILTER}=1; # a hack to prevent parse_xml_chunk from issuing end_document $self->{ParserOptions}{ParseFuncParam} = $chunk; $self->_parse; return; } sub _parse { my $self = shift; my $args = bless $self->{ParserOptions}, ref($self); if (defined($self->{JOIN_CHARACTERS})) { $args->{LibParser}->{JOIN_CHARACTERS} = $self->{JOIN_CHARACTERS}; } else { $args->{LibParser}->{JOIN_CHARACTERS} = 0; } $args->{LibParser}->set_handler( $self ); eval { $args->{ParseFunc}->($args->{LibParser}, $args->{ParseFuncParam}); }; if ( $args->{LibParser}->{SAX}->{State} == 1 ) { croak( "SAX Exception not implemented, yet; Data ended before document ended\n" ); } # break a possible circular reference $args->{LibParser}->set_handler( undef ); if ( $@ ) { croak $@; } return; } 1; PKM]P 33LibXML/DocumentFragment.podnu6$=head1 NAME XML::LibXML::DocumentFragment - XML::LibXML's DOM L2 Document Fragment Implementation =head1 SYNOPSIS use XML::LibXML; =head1 DESCRIPTION This class is a helper class as described in the DOM Level 2 Specification. It is implemented as a node without name. All adding, inserting or replacing functions are aware of document fragments now. As well I<<<<<< all >>>>>> unbound nodes (all nodes that do not belong to any document sub-tree) are implicit members of document fragments. =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]x!!LibXML/Error.pmnu6$# $Id: Error.pm,v 1.1.2.1 2004/04/20 20:09:48 pajas Exp $ # # This is free software, you may use it and distribute it under the same terms as # Perl itself. # # Copyright 2001-2003 AxKit.com Ltd., 2002-2006 Christian Glahn, 2006-2009 Petr Pajas # # package XML::LibXML::Error; use strict; use warnings; # To avoid a "Deep recursion on subroutine as_string" warning no warnings 'recursion'; use Encode (); use overload '""' => \&as_string, 'eq' => sub { ("$_[0]" eq "$_[1]") }, 'cmp' => sub { ("$_[0]" cmp "$_[1]") }, fallback => 1; our $WARNINGS = 0; # 0: suppress, 1: report via warn, 2: report via die our $VERSION = "2.0213"; # VERSION TEMPLATE: DO NOT CHANGE use constant XML_ERR_NONE => 0; use constant XML_ERR_WARNING => 1; # A simple warning use constant XML_ERR_ERROR => 2; # A recoverable error use constant XML_ERR_FATAL => 3; # A fatal error use constant XML_ERR_FROM_NONE => 0; use constant XML_ERR_FROM_PARSER => 1; # The XML parser use constant XML_ERR_FROM_TREE => 2; # The tree module use constant XML_ERR_FROM_NAMESPACE => 3; # The XML Namespace module use constant XML_ERR_FROM_DTD => 4; # The XML DTD validation use constant XML_ERR_FROM_HTML => 5; # The HTML parser use constant XML_ERR_FROM_MEMORY => 6; # The memory allocator use constant XML_ERR_FROM_OUTPUT => 7; # The serialization code use constant XML_ERR_FROM_IO => 8; # The Input/Output stack use constant XML_ERR_FROM_FTP => 9; # The FTP module use constant XML_ERR_FROM_HTTP => 10; # The FTP module use constant XML_ERR_FROM_XINCLUDE => 11; # The XInclude processing use constant XML_ERR_FROM_XPATH => 12; # The XPath module use constant XML_ERR_FROM_XPOINTER => 13; # The XPointer module use constant XML_ERR_FROM_REGEXP => 14; # The regular expressions module use constant XML_ERR_FROM_DATATYPE => 15; # The W3C XML Schemas Datatype module use constant XML_ERR_FROM_SCHEMASP => 16; # The W3C XML Schemas parser module use constant XML_ERR_FROM_SCHEMASV => 17; # The W3C XML Schemas validation module use constant XML_ERR_FROM_RELAXNGP => 18; # The Relax-NG parser module use constant XML_ERR_FROM_RELAXNGV => 19; # The Relax-NG validator module use constant XML_ERR_FROM_CATALOG => 20; # The Catalog module use constant XML_ERR_FROM_C14N => 21; # The Canonicalization module use constant XML_ERR_FROM_XSLT => 22; # The XSLT engine from libxslt use constant XML_ERR_FROM_VALID => 23; # The DTD validation module with valid context use constant XML_ERR_FROM_CHECK => 24; # The error-checking module use constant XML_ERR_FROM_WRITER => 25; # The xmlwriter module use constant XML_ERR_FROM_MODULE => 26; # The dynamically-loaded module module use constant XML_ERR_FROM_I18N => 27; # The module handling character conversion use constant XML_ERR_FROM_SCHEMATRONV=> 28; # The Schematron validator module our @error_domains = ("", "parser", "tree", "namespace", "validity", "HTML parser", "memory", "output", "I/O", "ftp", "http", "XInclude", "XPath", "xpointer", "regexp", "Schemas datatype", "Schemas parser", "Schemas validity", "Relax-NG parser", "Relax-NG validity", "Catalog", "C14N", "XSLT", "validity", "error-checking", "xmlwriter", "dynamic loading", "i18n", "Schematron validity"); my $MAX_ERROR_PREV_DEPTH = 100; for my $field (qw) { my $method = sub { $_[0]{$field} }; no strict 'refs'; *$field = $method; } { sub new { my ($class,$xE) = @_; my $terr; if (ref($xE)) { my ($context,$column) = $xE->context_and_column(); $terr =bless { domain => $xE->domain(), level => $xE->level(), code => $xE->code(), message => $xE->message(), file => $xE->file(), line => $xE->line(), str1 => $xE->str1(), str2 => $xE->str2(), str3 => $xE->str3(), num1 => $xE->num1(), num2 => $xE->num2(), __prev_depth => 0, (defined($context) ? ( context => $context, column => $column, ) : ()), }, $class; } else { # !!!! problem : got a flat error # warn("PROBLEM: GOT A FLAT ERROR $xE\n"); $terr =bless { domain => 0, level => 2, code => -1, message => $xE, file => undef, line => undef, str1 => undef, str2 => undef, str3 => undef, num1 => undef, num2 => undef, __prev_depth => 0, }, $class; } return $terr; } sub _callback_error { #print "CALLBACK\n"; my ($xE,$prev) = @_; my $terr; $terr=XML::LibXML::Error->new($xE); if ($terr->{level} == XML_ERR_WARNING and $WARNINGS!=2) { warn $terr if $WARNINGS; return $prev; } #unless ( defined $terr->{file} and length $terr->{file} ) { # this would make it easier to recognize parsed strings # but it breaks old implementations # [CG] $terr->{file} = 'string()'; #} #warn "Saving the error ",$terr->dump; if (ref($prev)) { if ($prev->__prev_depth() >= $MAX_ERROR_PREV_DEPTH) { return $prev; } $terr->{_prev} = $prev; $terr->{__prev_depth} = $prev->__prev_depth() + 1; } else { $terr->{_prev} = defined($prev) && length($prev) ? XML::LibXML::Error->new($prev) : undef; } return $terr; } sub _instant_error_callback { my $xE = shift; my $terr= XML::LibXML::Error->new($xE); print "Reporting an instanteous error ",$terr->dump; die $terr; } sub _report_warning { my ($saved_error) = @_; #print "CALLBACK WARN\n"; if ( defined $saved_error ) { #print "reporting a warning ",$saved_error->dump; warn $saved_error; } } sub _report_error { my ($saved_error) = @_; #print "CALLBACK ERROR: $saved_error\n"; if ( defined $saved_error ) { die $saved_error; } } } # backward compatibility sub int1 { $_[0]->num1 } sub int2 { $_[0]->num2 } sub domain { my ($self)=@_; return undef unless ref($self); my $domain = $self->{domain}; # Newer versions of libxml2 might yield errors in domains that aren't # listed above. Invent something reasonable in that case. return $domain < @error_domains ? $error_domains[$domain] : "domain_$domain"; } sub as_string { my ($self)=@_; my $msg = ""; my $level; if (defined($self->{_prev})) { $msg = $self->{_prev}->as_string; } if ($self->{level} == XML_ERR_NONE) { $level = ""; } elsif ($self->{level} == XML_ERR_WARNING) { $level = "warning"; } elsif ($self->{level} == XML_ERR_ERROR || $self->{level} == XML_ERR_FATAL) { $level = "error"; } my $where=""; if (defined($self->{file})) { $where="$self->{file}:$self->{line}"; } elsif (($self->{domain} == XML_ERR_FROM_PARSER) and $self->{line}) { $where="Entity: line $self->{line}"; } if ($self->{nodename}) { $where.=": element ".$self->{nodename}; } $msg.=$where.": " if $where ne ""; $msg.=$self->domain." ".$level." :"; my $str=$self->{message}||""; chomp($str); $msg.=" ".$str."\n"; if (($self->{domain} == XML_ERR_FROM_XPATH) and defined($self->{str1})) { $msg.=$self->{str1}."\n"; $msg.=(" " x $self->{num1})."^\n"; } elsif (defined $self->{context}) { # If the error relates to character-encoding problems in the context, # then doing textual operations on it will spew warnings that # XML::LibXML can do nothing to fix. So just disable all such # warnings. This has the pleasing benefit of making the test suite # run warning-free. no warnings 'utf8'; my $context = Encode::encode('UTF-8', $self->{context}); $msg.=$context."\n"; $context = substr($context,0,$self->{column}); $context=~s/[^\t]/ /g; $msg.=$context."^\n"; } return $msg; } sub dump { my ($self)=@_; require Data::Dumper; return Data::Dumper->new([$self],['error'])->Dump; } 1; PKM]l?l l LibXML/XPathContext.pmnu6$# $Id: XPathContext.pm 422 2002-11-08 17:10:30Z phish $ # # This is free software, you may use it and distribute it under the same terms as # Perl itself. # # Copyright 2001-2003 AxKit.com Ltd., 2002-2006 Christian Glahn, 2006-2009 Petr Pajas # # package XML::LibXML::XPathContext; use strict; use warnings; use Carp; use XML::LibXML; use XML::LibXML::NodeList; our $VERSION = "2.0213"; # VERSION TEMPLATE: DO NOT CHANGE # should LibXML XPath data types be used for simple objects # when passing parameters to extension functions (default: no) our $USE_LIBXML_DATA_TYPES = 0; sub CLONE_SKIP { 1 } sub findnodes { my ($self, $xpath, $node) = @_; my @nodes = $self->_guarded_find_call('_findnodes', $node, $xpath); if (wantarray) { return @nodes; } else { return XML::LibXML::NodeList->new(@nodes); } } sub find { my ($self, $xpath, $node) = @_; my ($type, @params) = $self->_guarded_find_call('_find', $node, $xpath,0); if ($type) { return $type->new(@params); } return undef; } sub exists { my ($self, $xpath, $node) = @_; my (undef, $value) = $self->_guarded_find_call('_find', $node, $xpath,1); return $value; } sub findvalue { my $self = shift; return $self->find(@_)->to_literal->value; } sub _guarded_find_call { my ($self, $method, $node)=(shift,shift,shift); my $prev_node; if (ref($node)) { $prev_node = $self->getContextNode(); $self->setContextNode($node); } my @ret; eval { @ret = $self->$method(@_); }; $self->_free_node_pool; $self->setContextNode($prev_node) if ref($node); if ($@) { my $err = $@; chomp $err; croak $err; } return @ret; } sub registerFunction { my ($self, $name, $sub) = @_; $self->registerFunctionNS($name, undef, $sub); return; } sub unregisterNs { my ($self, $prefix) = @_; $self->registerNs($prefix, undef); return; } sub unregisterFunction { my ($self, $name) = @_; $self->registerFunctionNS($name, undef, undef); return; } sub unregisterFunctionNS { my ($self, $name, $ns) = @_; $self->registerFunctionNS($name, $ns, undef); return; } sub unregisterVarLookupFunc { my ($self) = @_; $self->registerVarLookupFunc(undef, undef); return; } # extension function perl dispatcher # borrowed from XML::LibXSLT sub _perl_dispatcher { my $func = shift; my @params = @_; my @perlParams; my $i = 0; while (@params) { my $type = shift(@params); if ($type eq 'XML::LibXML::Literal' or $type eq 'XML::LibXML::Number' or $type eq 'XML::LibXML::Boolean') { my $val = shift(@params); unshift(@perlParams, $USE_LIBXML_DATA_TYPES ? $type->new($val) : $val); } elsif ($type eq 'XML::LibXML::NodeList') { my $node_count = shift(@params); unshift(@perlParams, $type->new(splice(@params, 0, $node_count))); } } $func = "main::$func" unless ref($func) || $func =~ /(.+)::/; no strict 'refs'; my $res = $func->(@perlParams); return $res; } 1; PKM]`9_XXLibXML/Common.podnu6$=head1 NAME XML::LibXML::Common - Constants and Character Encoding Routines =head1 SYNOPSIS use XML::LibXML::Common; $encodedstring = encodeToUTF8( $name_of_encoding, $sting_to_encode ); $decodedstring = decodeFromUTF8($name_of_encoding, $string_to_decode ); =head1 DESCRIPTION XML::LibXML::Common defines constants for all node types and provides interface to libxml2 charset conversion functions. Since XML::LibXML use their own node type definitions, one may want to use XML::LibXML::Common in its compatibility mode: =head2 Exporter TAGS use XML::LibXML::Common qw(:libxml); C<<<<<< :libxml >>>>>> tag will use the XML::LibXML Compatibility mode, which defines the old 'XML_' node-type definitions. use XML::LibXML::Common qw(:gdome); C<<<<<< :gdome >>>>>> tag will use the XML::GDOME Compatibility mode, which defines the old 'GDOME_' node-type definitions. use XML::LibXML::Common qw(:w3c); This uses the nodetype definition names as specified for DOM. use XML::LibXML::Common qw(:encoding); This tag can be used to export only the charset encoding functions of XML::LibXML::Common. =head2 Exports By default the W3 definitions as defined in the DOM specifications and the encoding functions are exported by XML::LibXML::Common. =head2 Encoding functions To encode or decode a string to or from UTF-8, XML::LibXML::Common exports two functions, which provide an interface to the encoding support in C<<<<<< libxml2 >>>>>>. Which encodings are supported by these functions depends on how C<<<<<< libxml2 >>>>>> was compiled. UTF-16 is always supported and on most installations, ISO encodings are supported as well. This interface was useful for older versions of Perl. Since Perl >= 5.8 provides similar functions via the C<<<<<< Encode >>>>>> module, it is probably a good idea to use those instead. =over 4 =item encodeToUTF8 $encodedstring = encodeToUTF8( $name_of_encoding, $sting_to_encode ); The function will convert a byte string from the specified encoding to an UTF-8 encoded character string. =item decodeToUTF8 $decodedstring = decodeFromUTF8($name_of_encoding, $string_to_decode ); This function converts an UTF-8 encoded character string to a specified encoding. Note that the conversion can raise an error if the given string contains characters that cannot be represented in the target encoding. =back Both these functions report their errors on the standard error. If an error occurs the function will croak(). To catch the error information it is required to call the encoding function from within an eval block in order to prevent the entire script from being stopped on encoding error. =head2 A note on history Before XML::LibXML 1.70, this class was available as a separate CPAN distribution, intended to provide functionality shared between XML::LibXML, XML::GDOME, and possibly other modules. Since there seems to be no progress in this direction, we decided to merge XML::LibXML::Common 0.13 and XML::LibXML 1.70 to one CPAN distribution. The merge also naturally eliminates a practical and urgent problem experienced by many XML::LibXML users on certain platforms, namely mysterious misbehavior of XML::LibXML occurring if the installed (often pre-packaged) version of XML::LibXML::Common was compiled against an older version of libxml2 than XML::LibXML. =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]j[LibXML/NamedNodeMap.podnu6$=head1 NAME XML::LibXML::NamedNodeMap - A map for named nodes =head1 SYNOPSIS use XML::LibXML; my $map = XML::LibXML::NamedNodeMap->new(@nodes); my $nodes_list = $map->nodes(); my $node_with_index_2 = $map->item(2); my $length = $map->length; my $nodes_ref = $node->nodes() my $node_2 = $map->item(2); my $node = $map->getNamedItem('phone_number'); $map->setNamedItem($new_node) $map->removeNamedItem($name) =head1 DESCRIPTION XML::LibXML::NamedNodeMap maps nodes' names to nodes. =head1 METHODS =over 4 =item length my $length = $map->length; Returns the number of nodes in the map. =item nodes my $nodes_ref = $node->nodes() Returns a reference to the list of nodes. =item item my $node_2 = $map->item(2); Returns the node with the index of the argument (starting from 0) =item getNamedItem my $node = $map->getNamedItem('phone_number'); Returns the node with the name. =item setNamedItem $map->setNamedItem($new_node) Sets the node with the same name as C<<<<<< $new_node >>>>>> to C<<<<<< $new_node >>>>>>. =item removeNamedItem $map->removeNamedItem($name) Remove the item with the name C<<<<<< $name >>>>>>. =item getNamedItemNS I<<<<<< Not implemented yet. >>>>>>. =item setNamedItemNS I<<<<<< Not implemented yet. >>>>>>. =item removeNamedItemNS I<<<<<< Not implemented yet. >>>>>>. =back =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]aFHLibXML/Schema.podnu6$=head1 NAME XML::LibXML::Schema - XML Schema Validation =head1 SYNOPSIS use XML::LibXML; $doc = XML::LibXML->new->parse_file($url); $xmlschema = XML::LibXML::Schema->new( location => $filename_or_url, no_network => 1 ); $xmlschema = XML::LibXML::Schema->new( string => $xmlschemastring, no_network => 1 ); eval { $xmlschema->validate( $doc ); }; =head1 DESCRIPTION The XML::LibXML::Schema class is a tiny frontend to libxml2's XML Schema implementation. Currently it supports only schema parsing and document validation. As of 2.6.32, libxml2 only supports decimal types up to 24 digits (the standard requires at least 18). =head1 METHODS =over 4 =item new $xmlschema = XML::LibXML::Schema->new( location => $filename_or_url, no_network => 1 ); $xmlschema = XML::LibXML::Schema->new( string => $xmlschemastring, no_network => 1 ); The constructor of XML::LibXML::Schema needs to be called with list of parameters. At least location or string parameter is required to specify source of schema. Optional parameter no_network set to 1 cause that parser would not access network and optional parameter recover set 1 cause that parser would not call die() on errors. It is important, that each schema only have a single source. The location parameter allows one to parse a schema from the filesystem or a (non-HTTPS) URL. The string parameter will parse the schema from the given XML string. Note that the constructor will die() if the schema does not meed the constraints of the XML Schema specification. =item validate eval { $xmlschema->validate( $doc ); }; This function allows one to validate a (parsed) document against the given XML Schema. The argument of this function should be a L<<<<<< XML::LibXML::Document >>>>>> object. If this function succeeds, it will return 0, otherwise it will die() and report the errors found. Because of this validate() should be always evaluated. =back =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]銇e<<LibXML/Devel.pmnu6$# $Id: $ # This is free software, you may use it and distribute it under the same terms as # Perl itself. # # Copyright 2011 Joachim Zobel # package XML::LibXML::Devel; use strict; use warnings; use XML::LibXML; our $VERSION = "2.0213"; # VERSION TEMPLATE: DO NOT CHANGE use 5.008_000; use parent qw(Exporter); # This allows declaration use XML::LibXML::Devel ':all'; # If you do not need this, moving things directly into @EXPORT or @EXPORT_OK # will save memory. our %EXPORT_TAGS = ( 'all' => [ qw( node_to_perl node_from_perl refcnt_inc refcnt_dec refcnt fix_owner ) ] ); # mem_used is only compiled in when the installed libxml2 supports the # legacy memory-tracking API (removed in 2.14, deprecated by Apple SDKs). push @{ $EXPORT_TAGS{'all'} }, 'mem_used' if defined &XML::LibXML::Devel::mem_used; our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } ); # Preloaded methods go here. 1; __END__ =head1 NAME XML::LibXML::Devel - makes functions from LibXML.xs available =head1 SYNOPSIS /********************************************** * C functions you want to access */ xmlNode *return_node(); void receive_node(xmlNode *); ############################################### # XS Code void * xs_return_node CODE: RETVAL = return_node(); OUTPUT: RETVAL void xs_receive_node void *n CODE: receive_node(n); ############################################### # Perl code use XML::LibXML::Devel; sub return_node { my $raw_node = xs_return_node(); my $node = XML::LibXML::Devel::node_to_perl($raw_node); XML::LibXML::Devel::refcnt_inc($raw_node); return $node; } sub receive_node { my ($node) = @_; my $raw_node = XML::LibXML::Devel::node_from_perl($node); xs_receive_node($raw_node); XML::LibXML::Devel::refcnt_inc($raw_node); } =head1 DESCRIPTION C makes functions from LibXML.xs available that are needed to wrap libxml2 nodes in and out of XML::LibXML::Nodes. This gives cleaner dependencies than using LibXML.so directly. To XS a library that uses libxml2 nodes the first step is to do this so that xmlNodePtr is passed as void *. These raw nodes are then turned into libxml nodes by using this C functions. Be aware that this module is currently rather experimental. The function names may change if I XS more functions and introduce a reasonable naming convention. Be also aware that this module is a great tool to cause segfaults and introduce memory leaks. It does however provide a partial cure by making C available as C. =head1 FUNCTIONS =head2 NODE MANAGEMENT =over 1 =item node_to_perl node_to_perl($raw_node); Returns a LibXML::Node object. This has a proxy node with a reference counter and an owner attached. The raw node will be deleted as soon as the reference counter reaches zero. If the C library is keeping a pointer to the raw node, you need to call refcnt_inc immediately. You also need to replace xmlFreeNode by a call to refcnt_dec. =item node_to_perl node_from_perl($node); Returns a raw node. This is a void * pointer and you can do nothing but passing it to functions that treat it as an xmlNodePtr. The raw node will be freed as soon as its reference counter reaches zero. If the C library is keeping a pointer to the raw node, you need to call refcnt_inc immediately. You also need to replace xmlFreeNode by a call to refcnt_dec. =item refcnt_inc refcnt_inc($raw_node); Increments the raw nodes reference counter. The raw node must already be known to perl to have a reference counter. =item refcnt_dec refcnt_dec($raw_node); Decrements the raw nodes reference counter and returns the value it had before. if the counter becomes zero or less, this method will free the proxy node holding the reference counter. If the node is part of a subtree, refcnt_dec will fix the reference counts and delete the subtree if it is not required any more. =item refcnt refcnt($raw_node); Returns the value of the reference counter. =item fix_owner fix_owner($raw_node, $raw_parent); This functions fixes the reference counts for an entire subtree. it is very important to fix an entire subtree after node operations where the documents or the owner node may get changed. this method is aware about nodes that already belong to a certain owner node. =back =head2 MEMORY DEBUGGING =over 1 =item $ENV{DEBUG_MEMORY} BEGIN {$ENV{DEBUG_MEMORY} = 1;}; use XML::LibXML; This turns on libxml2 memory debugging. It must be set before XML::LibXML is loaded. =item mem_used mem_used(); Returns the number of bytes currently allocated. =back =head2 EXPORT None by default. =head1 SEE ALSO This was created to support the needs of Apache2::ModXml2. So this can serve as an example. =head1 AUTHOR Joachim Zobel Ejz-2011@heute-morgen.deE =head1 COPYRIGHT AND LICENSE Copyright (C) 2011 by Joachim Zobel This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself, either Perl version 5.10.1 or, at your option, any later version of Perl 5 you may have available. =cut PKM]˙LttLibXML/Comment.podnu6$=head1 NAME XML::LibXML::Comment - XML::LibXML Comment Class =head1 SYNOPSIS use XML::LibXML; # Only methods specific to Comment nodes are listed here, # see the XML::LibXML::Node manpage for other methods $node = XML::LibXML::Comment->new( $content ); =head1 DESCRIPTION This class provides all functions of L<<<<<< XML::LibXML::Text >>>>>>, but for comment nodes. This can be done, since only the output of the node types is different, but not the data structure. :-) =head1 METHODS The class inherits from L<<<<<< XML::LibXML::Node >>>>>>. The documentation for Inherited methods is not listed here. Many functions listed here are extensively documented in the DOM Level 3 specification (L<<<<<< http://www.w3.org/TR/DOM-Level-3-Core/ >>>>>>). Please refer to the specification for extensive documentation. =over 4 =item new $node = XML::LibXML::Comment->new( $content ); The constructor is the only provided function for this package. It is required, because I<<<<<< libxml2 >>>>>> treats text nodes and comment nodes slightly differently. =back =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]LibXML/AttributeHash.pmnu6$package XML::LibXML::AttributeHash; use strict; use warnings; use Scalar::Util qw//; use Tie::Hash; our @ISA = qw/Tie::Hash/; our $VERSION = "2.0213"; # VERSION TEMPLATE: DO NOT CHANGE BEGIN { *__HAS_WEAKEN = defined(&Scalar::Util::weaken) ? sub () { 1 } : sub () { 0 }; }; sub element { return $_[0][0]; } sub from_clark { my ($self, $str) = @_; if ($str =~ m! \{ (.+) \} (.+) !x) { return ($1, $2); } return (undef, $str); } sub to_clark { my ($self, $ns, $local) = @_; defined $ns ? "{$ns}$local" : $local; } sub all_keys { my ($self, @keys) = @_; my $elem = $self->element; foreach my $attr (defined($elem) ? $elem->attributes : ()) { if (! $attr->isa('XML::LibXML::Namespace')) { push @keys, $self->to_clark($attr->namespaceURI, $attr->localname); } } return sort @keys; } sub TIEHASH { my ($class, $element, %args) = @_; my $self = bless [$element, undef, \%args], $class; if (__HAS_WEAKEN and $args{weaken}) { Scalar::Util::weaken( $self->[0] ); } return $self; } sub STORE { my ($self, $key, $value) = @_; my ($key_ns, $key_local) = $self->from_clark($key); if (defined $key_ns) { return $self->element->setAttributeNS($key_ns, "xxx:$key_local", "$value"); } else { return $self->element->setAttribute($key_local, "$value"); } } sub FETCH { my ($self, $key) = @_; my ($key_ns, $key_local) = $self->from_clark($key); if (defined $key_ns) { return $self->element->getAttributeNS($key_ns, "$key_local"); } else { return $self->element->getAttribute($key_local); } } sub EXISTS { my ($self, $key) = @_; my ($key_ns, $key_local) = $self->from_clark($key); if (defined $key_ns) { return $self->element->hasAttributeNS($key_ns, "$key_local"); } else { return $self->element->hasAttribute($key_local); } } sub DELETE { my ($self, $key) = @_; my ($key_ns, $key_local) = $self->from_clark($key); if (defined $key_ns) { return $self->element->removeAttributeNS($key_ns, "$key_local"); } else { return $self->element->removeAttribute($key_local); } } sub FIRSTKEY { my ($self) = @_; my @keys = $self->all_keys; $self->[1] = \@keys; if (wantarray) { return ($keys[0], $self->FETCH($keys[0])); } $keys[0]; } sub NEXTKEY { my ($self, $lastkey) = @_; my @keys = defined $self->[1] ? @{ $self->[1] } : $self->all_keys; my $found; foreach my $k (@keys) { if ($k gt $lastkey) { $found = $k and last; } } if (!defined $found) { $self->[1] = undef; return; } if (wantarray) { return ($found, $self->FETCH($found)); } return $found; } sub SCALAR { my ($self) = @_; return $self->element; } sub CLEAR { my ($self) = @_; foreach my $k ($self->all_keys) { $self->DELETE($k); } return $self; } __PACKAGE__ __END__ =head1 NAME XML::LibXML::AttributeHash - tie an XML::LibXML::Element to a hash to access its attributes =head1 SYNOPSIS tie my %hash, 'XML::LibXML::AttributeHash', $element; $hash{'href'} = 'http://example.com/'; print $element->getAttribute('href') . "\n"; =head1 DESCRIPTION This class allows an element's attributes to be accessed as if they were a plain old Perl hash. Attribute names become hash keys. Namespaced attributes are keyed using Clark notation. my $XLINK = 'http://www.w3.org/1999/xlink'; tie my %hash, 'XML::LibXML::AttributeHash', $element; $hash{"{$XLINK}href"} = 'http://localhost/'; print $element->getAttributeNS($XLINK, 'href') . "\n"; There is rarely any need to use XML::LibXML::AttributeHash directly. In general, it is possible to take advantage of XML::LibXML::Element's overloading. The example in the SYNOPSIS could have been written: $element->{'href'} = 'http://example.com/'; print $element->getAttribute('href') . "\n"; The tie interface allows the passing of additional arguments to XML::LibXML::AttributeHash: tie my %hash, 'XML::LibXML::AttributeHash', $element, %args; Currently only one argument is supported, the boolean "weaken" which (if true) indicates that the tied object's reference to the element should be a weak reference. This is used by XML::LibXML::Element's overloading. The "weaken" argument is ignored if you don't have a working Scalar::Util::weaken. PKM] ffLibXML/Node.podnu6$=head1 NAME XML::LibXML::Node - Abstract Base Class of XML::LibXML Nodes =head1 SYNOPSIS use XML::LibXML; $name = $node->nodeName; $node->setNodeName( $newName ); $bool = $node->isSameNode( $other_node ); $bool = $node->isEqual( $other_node ); $num = $node->unique_key; $content = $node->nodeValue; $content = $node->textContent; $type = $node->nodeType; $node->unbindNode(); $childnode = $node->removeChild( $childnode ); $oldnode = $node->replaceChild( $newNode, $oldNode ); $node->replaceNode($newNode); $childnode = $node->appendChild( $childnode ); $childnode = $node->addChild( $childnode ); $node = $parent->addNewChild( $nsURI, $name ); $node->addSibling($newNode); $newnode =$node->cloneNode( $deep ); $parentnode = $node->parentNode; $nextnode = $node->nextSibling(); $nextnode = $node->nextNonBlankSibling(); $prevnode = $node->previousSibling(); $prevnode = $node->previousNonBlankSibling(); $boolean = $node->hasChildNodes(); $childnode = $node->firstChild; $childnode = $node->lastChild; $documentnode = $node->ownerDocument; $node = $node->getOwner; $node->setOwnerDocument( $doc ); $node->insertBefore( $newNode, $refNode ); $node->insertAfter( $newNode, $refNode ); @nodes = $node->findnodes( $xpath_expression ); $result = $node->find( $xpath_expression ); print $node->findvalue( $xpath_expression ); $bool = $node->exists( $xpath_expression ); @childnodes = $node->childNodes(); @childnodes = $node->nonBlankChildNodes(); $xmlstring = $node->toString($format,$docencoding); $c14nstring = $node->toStringC14N(); $c14nstring = $node->toStringC14N($with_comments, $xpath_expression , $xpath_context); $c14nstring = $node->toStringC14N_v1_1(); $c14nstring = $node->toStringC14N_v1_1($with_comments, $xpath_expression , $xpath_context); $ec14nstring = $node->toStringEC14N(); $ec14nstring = $node->toStringEC14N($with_comments, $xpath_expression, $inclusive_prefix_list); $ec14nstring = $node->toStringEC14N($with_comments, $xpath_expression, $xpath_context, $inclusive_prefix_list); $str = $doc->serialize($format); $localname = $node->localname; $nameprefix = $node->prefix; $uri = $node->namespaceURI(); $boolean = $node->hasAttributes(); @attributelist = $node->attributes(); $URI = $node->lookupNamespaceURI( $prefix ); $prefix = $node->lookupNamespacePrefix( $URI ); $node->normalize; @nslist = $node->getNamespaces; $node->removeChildNodes(); $strURI = $node->baseURI(); $node->setBaseURI($strURI); $node->nodePath(); $lineno = $node->line_number(); =head1 DESCRIPTION XML::LibXML::Node defines functions that are common to all Node Types. An XML::LibXML::Node should never be created standalone, but as an instance of a high level class such as XML::LibXML::Element or XML::LibXML::Text. The class itself should provide only common functionality. In XML::LibXML each node is part either of a document or a document-fragment. Because of this there is no node without a parent. This may causes confusion with "unbound" nodes. =head1 METHODS Many functions listed here are extensively documented in the DOM Level 3 specification (L<<<<<< http://www.w3.org/TR/DOM-Level-3-Core/ >>>>>>). Please refer to the specification for extensive documentation. =over 4 =item nodeName $name = $node->nodeName; Returns the node's name. This function is aware of namespaces and returns the full name of the current node (C<<<<<< prefix:localname >>>>>>). Since 1.62 this function also returns the correct DOM names for node types with constant names, namely: #text, #cdata-section, #comment, #document, #document-fragment. =item setNodeName $node->setNodeName( $newName ); In very limited situations, it is useful to change a nodes name. In the DOM specification this should throw an error. This Function is aware of namespaces. =item isSameNode $bool = $node->isSameNode( $other_node ); returns TRUE (1) if the given nodes refer to the same node structure, otherwise FALSE (0) is returned. =item isEqual $bool = $node->isEqual( $other_node ); deprecated version of isSameNode(). I<<<<<< NOTE >>>>>> isEqual will change behaviour to follow the DOM specification =item unique_key $num = $node->unique_key; This function is not specified for any DOM level. It returns a key guaranteed to be unique for this node, and to always be the same value for this node. In other words, two node objects return the same key if and only if isSameNode indicates that they are the same node. The returned key value is useful as a key in hashes. =item nodeValue $content = $node->nodeValue; If the node has any content (such as stored in a C<<<<<< text node >>>>>>) it can get requested through this function. I<<<<<< NOTE: >>>>>> Element Nodes have no content per definition. To get the text value of an Element use textContent() instead! =item textContent $content = $node->textContent; this function returns the content of all text nodes in the descendants of the given node as specified in DOM. =item nodeType $type = $node->nodeType; Return a numeric value representing the node type of this node. The module XML::LibXML by default exports constants for the node types (see the EXPORT section in the L<<<<<< XML::LibXML >>>>>> manual page). =item unbindNode $node->unbindNode(); Unbinds the Node from its siblings and Parent, but not from the Document it belongs to. If the node is not inserted into the DOM afterwards, it will be lost after the program terminates. From a low level view, the unbound node is stripped from the context it is and inserted into a (hidden) document-fragment. =item removeChild $childnode = $node->removeChild( $childnode ); This will unbind the Child Node from its parent C<<<<<< $node >>>>>>. The function returns the unbound node. If C<<<<<< $childnode >>>>>> is not a child of the given Node the function will fail. =item replaceChild $oldnode = $node->replaceChild( $newNode, $oldNode ); Replaces the C<<<<<< $oldNode >>>>>> with the C<<<<<< $newNode >>>>>>. The C<<<<<< $oldNode >>>>>> will be unbound from the Node. This function differs from the DOM L2 specification, in the case, if the new node is not part of the document, the node will be imported first. =item replaceNode $node->replaceNode($newNode); This function is very similar to replaceChild(), but it replaces the node itself rather than a childnode. This is useful if a node found by any XPath function, should be replaced. =item appendChild $childnode = $node->appendChild( $childnode ); The function will add the C<<<<<< $childnode >>>>>> to the end of C<<<<<< $node >>>>>>'s children. The function should fail, if the new childnode is already a child of C<<<<<< $node >>>>>>. This function differs from the DOM L2 specification, in the case, if the new node is not part of the document, the node will be imported first. =item addChild $childnode = $node->addChild( $childnode ); As an alternative to appendChild() one can use the addChild() function. This function is a bit faster, because it avoids all DOM conformity checks. Therefore this function is quite useful if one builds XML documents in memory where the order and ownership (C<<<<<< ownerDocument >>>>>>) is assured. addChild() uses libxml2's own xmlAddChild() function. Thus it has to be used with extra care: If a text node is added to a node and the node itself or its last childnode is as well a text node, the node to add will be merged with the one already available. The current node will be removed from memory after this action. Because perl is not aware of this action, the perl instance is still available. XML::LibXML will catch the loss of a node and refuse to run any function called on that node. my $t1 = $doc->createTextNode( "foo" ); my $t2 = $doc->createTextNode( "bar" ); $t1->addChild( $t2 ); # is OK my $val = $t2->nodeValue(); # will fail, script dies Also addChild() will not check if the added node belongs to the same document as the node it will be added to. This could lead to inconsistent documents and in more worse cases even to memory violations, if one does not keep track of this issue. Although this sounds like a lot of trouble, addChild() is useful if a document is built from a stream, such as happens sometimes in SAX handlers or filters. If you are not sure about the source of your nodes, you better stay with appendChild(), because this function is more user friendly in the sense of being more error tolerant. =item addNewChild $node = $parent->addNewChild( $nsURI, $name ); Similar to C<<<<<< addChild() >>>>>>, this function uses low level libxml2 functionality to provide faster interface for DOM building. I<<<<<< addNewChild() >>>>>> uses C<<<<<< xmlNewChild() >>>>>> to create a new node on a given parent element. addNewChild() has two parameters $nsURI and $name, where $nsURI is an (optional) namespace URI. $name is the fully qualified element name; addNewChild() will determine the correct prefix if necessary. The function returns the newly created node. This function is very useful for DOM building, where a created node can be directly associated with its parent. I<<<<<< NOTE >>>>>> this function is not part of the DOM specification and its use will limit your code to XML::LibXML. =item addSibling $node->addSibling($newNode); addSibling() allows adding an additional node to the end of a nodelist, defined by the given node. =item cloneNode $newnode =$node->cloneNode( $deep ); I<<<<<< cloneNode >>>>>> creates a copy of C<<<<<< $node >>>>>>. When $deep is set to 1 (true) the function will copy all child nodes as well. If $deep is 0 only the current node will be copied. Note that in case of element, attributes are copied even if $deep is 0. Note that the behavior of this function for $deep=0 has changed in 1.62 in order to be consistent with the DOM spec (in older versions attributes and namespace information was not copied for elements). I<<<<<< NOTE >>>>>>cloneNode creates a copy of the selected node that includes the parent's defined I<<<<<< namespaces >>>>>> that are in use by the node (or its children) being cloned. That makes it useful for extracting a fragment of xml that can be used as a valid xml document. =item parentNode $parentnode = $node->parentNode; Returns simply the Parent Node of the current node. =item nextSibling $nextnode = $node->nextSibling(); Returns the next sibling, if any. =item nextNonBlankSibling $nextnode = $node->nextNonBlankSibling(); Returns the next non-blank sibling if any (a node is blank if it is a Text or CDATA node consisting of whitespace only). This method is not defined by DOM. =item previousSibling $prevnode = $node->previousSibling(); Analogous to I<<<<<< getNextSibling >>>>>> the function returns the previous sibling if any. =item previousNonBlankSibling $prevnode = $node->previousNonBlankSibling(); Returns the previous non-blank sibling if any (a node is blank if it is a Text or CDATA node consisting of whitespace only). This method is not defined by DOM. =item hasChildNodes $boolean = $node->hasChildNodes(); If the current node has child nodes this function returns TRUE (1), otherwise it returns FALSE (0, not undef). =item firstChild $childnode = $node->firstChild; If a node has child nodes this function will return the first node in the child list. =item lastChild $childnode = $node->lastChild; If the C<<<<<< $node >>>>>> has child nodes this function returns the last child node. =item ownerDocument $documentnode = $node->ownerDocument; Through this function it is always possible to access the document the current node is bound to. =item getOwner $node = $node->getOwner; This function returns the node the current node is associated with. In most cases this will be a document node or a document fragment node. =item setOwnerDocument $node->setOwnerDocument( $doc ); This function binds a node to another DOM. This method unbinds the node first, if it is already bound to another document. This function is the opposite calling of L<<<<<< XML::LibXML::Document >>>>>>'s adoptNode() function. Because of this it has the same limitations with Entity References as adoptNode(). =item insertBefore $node->insertBefore( $newNode, $refNode ); The method inserts C<<<<<< $newNode >>>>>> before C<<<<<< $refNode >>>>>>. If C<<<<<< $refNode >>>>>> is undefined, the newNode will be set as the new last child of the parent node. This function differs from the DOM L2 specification, in the case, if the new node is not part of the document, the node will be imported first, automatically. $refNode has to be passed to the function even if it is undefined: $node->insertBefore( $newNode, undef ); # the same as $node->appendChild( $newNode ); $node->insertBefore( $newNode ); # wrong Note, that the reference node has to be a direct child of the node the function is called on. Also, $newChild is not allowed to be an ancestor of the new parent node. =item insertAfter $node->insertAfter( $newNode, $refNode ); The method inserts C<<<<<< $newNode >>>>>> after C<<<<<< $refNode >>>>>>. If C<<<<<< $refNode >>>>>> is undefined, the newNode will be set as the new last child of the parent node. Note, that $refNode has to be passed explicitly even if it is undef. =item findnodes @nodes = $node->findnodes( $xpath_expression ); I<<<<<< findnodes >>>>>> evaluates the xpath expression (XPath 1.0) on the current node and returns the resulting node set as an array. In scalar context, returns an L<<<<<< XML::LibXML::NodeList >>>>>> object. The xpath expression can be passed either as a string, or as a L<<<<<< XML::LibXML::XPathExpression >>>>>> object. I<<<<<< NOTE ON NAMESPACES AND XPATH >>>>>>: A common mistake about XPath is to assume that node tests consisting of an element name with no prefix match elements in the default namespace. This assumption is wrong - by XPath specification, such node tests can only match elements that are in no (i.e. null) namespace. So, for example, one cannot match the root element of an XHTML document with C<<<<<< $node-Efind('/html') >>>>>> since C<<<<<< '/html' >>>>>> would only match if the root element C<<<<<< EhtmlE >>>>>> had no namespace, but all XHTML elements belong to the namespace http://www.w3.org/1999/xhtml. (Note that C<<<<<< xmlns="..." >>>>>> namespace declarations can also be specified in a DTD, which makes the situation even worse, since the XML document looks as if there was no default namespace). There are several possible ways to deal with namespaces in XPath: =over 4 =item * The recommended way is to use the L<<<<<< XML::LibXML::XPathContext >>>>>> module to define an explicit context for XPath evaluation, in which a document independent prefix-to-namespace mapping can be defined. For example: my $xpc = XML::LibXML::XPathContext->new; $xpc->registerNs('x', 'http://www.w3.org/1999/xhtml'); $xpc->find('/x:html',$node); =item * Another possibility is to use prefixes declared in the queried document (if known). If the document declares a prefix for the namespace in question (and the context node is in the scope of the declaration), C<<<<<< XML::LibXML >>>>>> allows you to use the prefix in the XPath expression, e.g.: $node->find('/x:html'); =back See also XML::LibXML::XPathContext->findnodes. =item find $result = $node->find( $xpath_expression ); I<<<<<< find >>>>>> evaluates the XPath 1.0 expression using the current node as the context of the expression, and returns the result depending on what type of result the XPath expression had. For example, the XPath "1 * 3 + 52" results in a L<<<<<< XML::LibXML::Number >>>>>> object being returned. Other expressions might return an L<<<<<< XML::LibXML::Boolean >>>>>> object, or an L<<<<<< XML::LibXML::Literal >>>>>> object (a string). Each of those objects uses Perl's overload feature to "do the right thing" in different contexts. The xpath expression can be passed either as a string, or as a L<<<<<< XML::LibXML::XPathExpression >>>>>> object. See also L<<<<<< XML::LibXML::XPathContext >>>>>>->find. =item findvalue print $node->findvalue( $xpath_expression ); I<<<<<< findvalue >>>>>> is exactly equivalent to: $node->find( $xpath_expression )->to_literal; That is, it returns the literal value of the results. This enables you to ensure that you get a string back from your search, allowing certain shortcuts. This could be used as the equivalent of XSLT's . See also L<<<<<< XML::LibXML::XPathContext >>>>>>->findvalue. The xpath expression can be passed either as a string, or as a L<<<<<< XML::LibXML::XPathExpression >>>>>> object. =item exists $bool = $node->exists( $xpath_expression ); This method behaves like I<<<<<< findnodes >>>>>>, except that it only returns a boolean value (1 if the expression matches a node, 0 otherwise) and may be faster than I<<<<<< findnodes >>>>>>, because the XPath evaluation may stop early on the first match (this is true for libxml2 >= 2.6.27). For XPath expressions that do not return node-set, the method returns true if the returned value is a non-zero number or a non-empty string. =item childNodes @childnodes = $node->childNodes(); I<<<<<< childNodes >>>>>> implements a more intuitive interface to the childnodes of the current node. It enables you to pass all children directly to a C<<<<<< map >>>>>> or C<<<<<< grep >>>>>>. If this function is called in scalar context, a L<<<<<< XML::LibXML::NodeList >>>>>> object will be returned. =item nonBlankChildNodes @childnodes = $node->nonBlankChildNodes(); This is like I<<<<<< childNodes >>>>>>, but returns only non-blank nodes (where a node is blank if it is a Text or CDATA node consisting of whitespace only). This method is not defined by DOM. =item toString $xmlstring = $node->toString($format,$docencoding); This method is similar to the method C<<<<<< toString >>>>>> of a L<<<<<< XML::LibXML::Document >>>>>> but for a single node. It returns a string consisting of XML serialization of the given node and all its descendants. Unlike C<<<<<< XML::LibXML::Document::toString >>>>>>, in this case the resulting string is by default a character string (UTF-8 encoded with UTF8 flag on). An optional flag $format controls indentation, as in C<<<<<< XML::LibXML::Document::toString >>>>>>. If the second optional $docencoding flag is true, the result will be a byte string in the document encoding (see C<<<<<< XML::LibXML::Document::actualEncoding >>>>>>). =item toStringC14N $c14nstring = $node->toStringC14N(); $c14nstring = $node->toStringC14N($with_comments, $xpath_expression , $xpath_context); The function is similar to toString(). Instead of simply serializing the document tree, it transforms it as it is specified in the XML-C14N Specification (see L<<<<<< http://www.w3.org/TR/xml-c14n >>>>>>). Such transformation is known as canonization. If $with_comments is 0 or not defined, the result-document will not contain any comments that exist in the original document. To include comments into the canonized document, $with_comments has to be set to 1. The parameter $xpath_expression defines the nodeset of nodes that should be visible in the resulting document. This can be used to filter out some nodes. One has to note, that only the nodes that are part of the nodeset, will be included into the result-document. Their child-nodes will not exist in the resulting document, unless they are part of the nodeset defined by the xpath expression. If $xpath_expression is omitted or empty, toStringC14N() will include all nodes in the given sub-tree, using the following XPath expressions: with comments (. | .//node() | .//@* | .//namespace::*) and without comments (. | .//node() | .//@* | .//namespace::*)[not(self::comment())] An optional parameter $xpath_context can be used to pass an L<<<<<< XML::LibXML::XPathContext >>>>>> object defining the context for evaluation of $xpath_expression. This is useful for mapping namespace prefixes used in the XPath expression to namespace URIs. Note, however, that $node will be used as the context node for the evaluation, not the context node of $xpath_context! =item toStringC14N_v1_1 $c14nstring = $node->toStringC14N_v1_1(); $c14nstring = $node->toStringC14N_v1_1($with_comments, $xpath_expression , $xpath_context); This function behaves like toStringC14N() except that it uses the "XML_C14N_1_1" constant for canonicalising using the "C14N 1.1 spec". =item toStringEC14N $ec14nstring = $node->toStringEC14N(); $ec14nstring = $node->toStringEC14N($with_comments, $xpath_expression, $inclusive_prefix_list); $ec14nstring = $node->toStringEC14N($with_comments, $xpath_expression, $xpath_context, $inclusive_prefix_list); The function is similar to toStringC14N() but follows the XML-EXC-C14N Specification (see L<<<<<< http://www.w3.org/TR/xml-exc-c14n >>>>>>) for exclusive canonization of XML. The arguments $with_comments, $xpath_expression, $xpath_context are as in toStringC14N(). An ARRAY reference can be passed as the last argument $inclusive_prefix_list, listing namespace prefixes that are to be handled in the manner described by the Canonical XML Recommendation (i.e. preserved in the output even if the namespace is not used). C.f. the spec for details. =item serialize $str = $doc->serialize($format); An alias for toString(). This function was name added to be more consistent with libxml2. =item serialize_c14n An alias for toStringC14N(). =item serialize_exc_c14n An alias for toStringEC14N(). =item localname $localname = $node->localname; Returns the local name of a tag. This is the part behind the colon. =item prefix $nameprefix = $node->prefix; Returns the prefix of a tag. This is the part before the colon. =item namespaceURI $uri = $node->namespaceURI(); returns the URI of the current namespace. =item hasAttributes $boolean = $node->hasAttributes(); returns 1 (TRUE) if the current node has any attributes set, otherwise 0 (FALSE) is returned. =item attributes @attributelist = $node->attributes(); This function returns all attributes and namespace declarations assigned to the given node. Because XML::LibXML does not implement namespace declarations and attributes the same way, it is required to test what kind of node is handled while accessing the functions result. If this function is called in array context the attribute nodes are returned as an array. In scalar context, the function will return a L<<<<<< XML::LibXML::NamedNodeMap >>>>>> object. =item lookupNamespaceURI $URI = $node->lookupNamespaceURI( $prefix ); Find a namespace URI by its prefix starting at the current node. =item lookupNamespacePrefix $prefix = $node->lookupNamespacePrefix( $URI ); Find a namespace prefix by its URI starting at the current node. I<<<<<< NOTE >>>>>> Only the namespace URIs are meant to be unique. The prefix is only document related. Also the document might have more than a single prefix defined for a namespace. =item normalize $node->normalize; This function normalizes adjacent text nodes. This function is not as strict as libxml2's xmlTextMerge() function, since it will not free a node that is still referenced by the perl layer. =item getNamespaces @nslist = $node->getNamespaces; If a node has any namespaces defined, this function will return these namespaces. Note, that this will not return all namespaces that are in scope, but only the ones declared explicitly for that node. Although getNamespaces is available for all nodes, it only makes sense if used with element nodes. =item removeChildNodes $node->removeChildNodes(); This function is not specified for any DOM level: It removes all childnodes from a node in a single step. Other than the libxml2 function itself (xmlFreeNodeList), this function will not immediately remove the nodes from the memory. This saves one from getting memory violations, if there are nodes still referred to from the Perl level. =item baseURI () $strURI = $node->baseURI(); Searches for the base URL of the node. The method should work on both XML and HTML documents even if base mechanisms for these are completely different. It returns the base as defined in RFC 2396 sections "5.1.1. Base URI within Document Content" and "5.1.2. Base URI from the Encapsulating Entity". However it does not return the document base (5.1.3), use method C<<<<<< URI >>>>>> of C<<<<<< XML::LibXML::Document >>>>>> for this. =item setBaseURI ($strURI) $node->setBaseURI($strURI); This method only does something useful for an element node in an XML document. It sets the xml:base attribute on the node to $strURI, which effectively sets the base URI of the node to the same value. Note: For HTML documents this behaves as if the document was XML which may not be desired, since it does not effectively set the base URI of the node. See RFC 2396 appendix D for an example of how base URI can be specified in HTML. =item nodePath $node->nodePath(); This function is not specified for any DOM level: It returns a canonical structure based XPath for a given node. =item line_number $lineno = $node->line_number(); This function returns the line number where the tag was found during parsing. If a node is added to the document the line number is 0. Problems may occur, if a node from one document is passed to another one. IMPORTANT: Due to limitations in the libxml2 library line numbers greater than 65535 will be returned as 65535. Please see L<<<<<< http://bugzilla.gnome.org/show_bug.cgi?id=325533 >>>>>> for more details. Note: line_number() is special to XML::LibXML and not part of the DOM specification. If the line_numbers flag of the parser was not activated before parsing, line_number() will always return 0. =back =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]APSLibXML/DOM.podnu6$=head1 NAME XML::LibXML::DOM - XML::LibXML DOM Implementation =head1 DESCRIPTION XML::LibXML provides a lightweight interface to I<<<<<< modify >>>>>> a node of the document tree generated by the XML::LibXML parser. This interface follows as far as possible the DOM Level 3 specification. In addition to the specified functions, XML::LibXML supports some functions that are more handy to use in the perl environment. One also has to remember, that XML::LibXML is an interface to libxml2 nodes which actually reside on the C-Level of XML::LibXML. This means each node is a reference to a structure which is different from a perl hash or array. The only way to access these structures' values is through the DOM interface provided by XML::LibXML. This also means, that one I<<<<<< can't >>>>>> simply inherit an XML::LibXML node and add new member variables as if they were hash keys. The DOM interface of XML::LibXML does not intend to implement a full DOM interface as it is done by XML::GDOME and used for full featured application. Moreover, it offers an simple way to build or modify documents that are created by XML::LibXML's parser. Another target of the XML::LibXML interface is to make the interfaces of libxml2 available to the perl community. This includes also some workarounds to some features where libxml2 assumes more control over the C-Level that most perl users don't have. One of the most important parts of the XML::LibXML DOM interface is that the interfaces try to follow the DOM Level 3 specification (L<<<<<< http://www.w3.org/TR/DOM-Level-3-Core/ >>>>>>) rather strictly. This means the interface functions are named as the DOM specification says and not what widespread Java interfaces claim to be the standard. Although there are several functions that have only a singular interface that conforms to the DOM spec XML::LibXML provides an additional Java style alias interface. Moreover, there are some function interfaces left over from early stages of XML::LibXML for compatibility reasons. These interfaces are for compatibility reasons I<<<<<< only >>>>>>. They might disappear in one of the future versions of XML::LibXML, so a user is requested to switch over to the official functions. =head2 Encodings and XML::LibXML's DOM implementation See the section on Encodings in the I<<<<<< XML::LibXML >>>>>> manual page. =head2 Namespaces and XML::LibXML's DOM implementation XML::LibXML's DOM implementation is limited by the DOM implementation of libxml2 which treats namespaces slightly differently than required by the DOM Level 2 specification. According to the DOM Level 2 specification, namespaces of elements and attributes should be persistent, and nodes should be permanently bound to namespace URIs as they get created; it should be possible to manipulate the special attributes used for declaring XML namespaces just as other attributes without affecting the namespaces of other nodes. In DOM Level 2, the application is responsible for creating the special attributes consistently and/or for correct serialization of the document. This is both inconvenient, causes problems in serialization of DOM to XML, and most importantly, seems almost impossible to implement over libxml2. In libxml2, namespace URI and prefix of a node is provided by a pointer to a namespace declaration (appearing as a special xmlns attribute in the XML document). If the prefix or namespace URI of the declaration changes, the prefix and namespace URI of all nodes that point to it changes as well. Moreover, in contrast to DOM, a node (element or attribute) can only be bound to a namespace URI if there is some namespace declaration in the document to point to. Therefore current DOM implementation in XML::LibXML tries to treat namespace declarations in a compromise between reason, common sense, limitations of libxml2, and the DOM Level 2 specification. In XML::LibXML, special attributes declaring XML namespaces are often created automatically, usually when a namespaced node is attached to a document and no existing declaration of the namespace and prefix is in the scope to be reused. In this respect, XML::LibXML DOM implementation differs from the DOM Level 2 specification according to which special attributes for declaring the appropriate XML namespaces should not be added when a node with a namespace prefix and namespace URI is created. Namespace declarations are also created when L<<<<<< XML::LibXML::Document >>>>>>'s createElementNS() or createAttributeNS() function are used. If the a namespace is not declared on the documentElement, the namespace will be locally declared for the newly created node. In case of Attributes this may look a bit confusing, since these nodes cannot have namespace declarations itself. In this case the namespace is internally applied to the attribute and later declared on the node the attribute is appended to (if required). The following example may explain this a bit: my $doc = XML::LibXML->createDocument; my $root = $doc->createElementNS( "", "foo" ); $doc->setDocumentElement( $root ); my $attr = $doc->createAttributeNS( "bar", "bar:foo", "test" ); $root->setAttributeNodeNS( $attr ); This piece of code will result in the following document: The namespace is declared on the document element during the setAttributeNodeNS() call. Namespaces can be also declared explicitly by the use of XML::LibXML::Element's setNamespace() function. Since 1.61, they can also be manipulated with functions setNamespaceDeclPrefix() and setNamespaceDeclURI() (not available in DOM). Changing an URI or prefix of an existing namespace declaration affects the namespace URI and prefix of all nodes which point to it (that is the nodes in its scope). It is also important to repeat the specification: While working with namespaces you should use the namespace aware functions instead of the simplified versions. For example you should I<<<<<< never >>>>>> use setAttribute() but setAttributeNS(). =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]tM  LibXML/SAX.podnu6$=head1 NAME XML::LibXML::SAX - XML::LibXML direct SAX parser =head1 DESCRIPTION XML::LibXML provides an interface to libxml2 direct SAX interface. Through this interface it is possible to generate SAX events directly while parsing a document. While using the SAX parser XML::LibXML will not create a DOM Document tree. Such an interface is useful if very large XML documents have to be processed and no DOM functions are required. By using this interface it is possible to read data stored within an XML document directly into the application data structures without loading the document into memory. The SAX interface of XML::LibXML is based on the famous XML::SAX interface. It uses the generic interface as provided by XML::SAX::Base. Additionally to the generic functions, which are only able to process entire documents, XML::LibXML::SAX provides I<<<<<< parse_chunk() >>>>>>. This method generates SAX events from well balanced data such as is often provided by databases. =head1 FEATURES I<<<<<< NOTE: >>>>>> This feature is experimental. You can enable character data joining which may yield a significant speed boost in your XML processing in lower markup ratio situations by enabling the http://xmlns.perl.org/sax/join-character-data feature of this parser. This is done via the set_feature method like this: $p->set_feature('http://xmlns.perl.org/sax/join-character-data', 1); You can also specify a 0 to disable. The default is to have this feature disabled. =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]B<6 LibXML/Pattern.podnu6$=head1 NAME XML::LibXML::Pattern - XML::LibXML::Pattern - interface to libxml2 XPath patterns =head1 SYNOPSIS use XML::LibXML; my $pattern = XML::LibXML::Pattern->new('/x:html/x:body//x:div', { 'x' => 'http://www.w3.org/1999/xhtml' }); # test a match on an XML::LibXML::Node $node if ($pattern->matchesNode($node)) { ... } # or on an XML::LibXML::Reader if ($reader->matchesPattern($pattern)) { ... } # or skip reading all nodes that do not match print $reader->nodePath while $reader->nextPatternMatch($pattern); $pattern = XML::LibXML::Pattern->new( pattern, { prefix => namespace_URI, ... } ); $bool = $pattern->matchesNode($node); =head1 DESCRIPTION This is a perl interface to libxml2's pattern matching support I<<<<<< http://xmlsoft.org/html/libxml-pattern.html >>>>>>. This feature requires recent versions of libxml2. Patterns are a small subset of XPath language, which is limited to (disjunctions of) location paths involving the child and descendant axes in abbreviated form as described by the extended BNF given below: Selector ::= Path ( '|' Path )* Path ::= ('.//' | '//' | '/' )? Step ( '/' Step )* Step ::= '.' | NameTest NameTest ::= QName | '*' | NCName ':' '*' For readability, whitespace may be used in selector XPath expressions even though not explicitly allowed by the grammar: whitespace may be freely added within patterns before or after any token, where token ::= '.' | '/' | '//' | '|' | NameTest Note that no predicates or attribute tests are allowed. Patterns are particularly useful for stream parsing provided via the C<<<<<< XML::LibXML::Reader >>>>>> interface. =over 4 =item new() $pattern = XML::LibXML::Pattern->new( pattern, { prefix => namespace_URI, ... } ); The constructor of a pattern takes a pattern expression (as described by the BNF grammar above) and an optional HASH reference mapping prefixes to namespace URIs. The method returns a compiled pattern object. Note that if the document has a default namespace, it must still be given an prefix in order to be matched (as demanded by the XPath 1.0 specification). For example, to match an element C<<<<<< Ea xmlns="http://foo.bar"E/aE >>>>>>, one should use a pattern like this: $pattern = XML::LibXML::Pattern->new( 'foo:a', { foo => 'http://foo.bar' }); =item matchesNode($node) $bool = $pattern->matchesNode($node); Given an XML::LibXML::Node object, returns a true value if the node is matched by the compiled pattern expression. =back =head1 SEE ALSO L<<<<<< XML::LibXML::Reader >>>>>> for other methods involving compiled patterns. =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]K@o@oLibXML/ErrNo.pmnu6$# $Id: ErrNo.pm,v 1.1.2.1 2004/04/20 20:09:48 pajas Exp $ # # # This is free software, you may use it and distribute it under the same terms as # Perl itself. # # Copyright 2001-2003 AxKit.com Ltd., 2002-2006 Christian Glahn, 2006-2009 Petr Pajas # # package XML::LibXML::ErrNo; use strict; use warnings; our $VERSION = "2.0213"; # VERSION TEMPLATE: DO NOT CHANGE use constant ERR_OK => 0; use constant ERR_INTERNAL_ERROR => 1; use constant ERR_NO_MEMORY => 2; use constant ERR_DOCUMENT_START => 3; use constant ERR_DOCUMENT_EMPTY => 4; use constant ERR_DOCUMENT_END => 5; use constant ERR_INVALID_HEX_CHARREF => 6; use constant ERR_INVALID_DEC_CHARREF => 7; use constant ERR_INVALID_CHARREF => 8; use constant ERR_INVALID_CHAR => 9; use constant ERR_CHARREF_AT_EOF => 10; use constant ERR_CHARREF_IN_PROLOG => 11; use constant ERR_CHARREF_IN_EPILOG => 12; use constant ERR_CHARREF_IN_DTD => 13; use constant ERR_ENTITYREF_AT_EOF => 14; use constant ERR_ENTITYREF_IN_PROLOG => 15; use constant ERR_ENTITYREF_IN_EPILOG => 16; use constant ERR_ENTITYREF_IN_DTD => 17; use constant ERR_PEREF_AT_EOF => 18; use constant ERR_PEREF_IN_PROLOG => 19; use constant ERR_PEREF_IN_EPILOG => 20; use constant ERR_PEREF_IN_INT_SUBSET => 21; use constant ERR_ENTITYREF_NO_NAME => 22; use constant ERR_ENTITYREF_SEMICOL_MISSING => 23; use constant ERR_PEREF_NO_NAME => 24; use constant ERR_PEREF_SEMICOL_MISSING => 25; use constant ERR_UNDECLARED_ENTITY => 26; use constant WAR_UNDECLARED_ENTITY => 27; use constant ERR_UNPARSED_ENTITY => 28; use constant ERR_ENTITY_IS_EXTERNAL => 29; use constant ERR_ENTITY_IS_PARAMETER => 30; use constant ERR_UNKNOWN_ENCODING => 31; use constant ERR_UNSUPPORTED_ENCODING => 32; use constant ERR_STRING_NOT_STARTED => 33; use constant ERR_STRING_NOT_CLOSED => 34; use constant ERR_NS_DECL_ERROR => 35; use constant ERR_ENTITY_NOT_STARTED => 36; use constant ERR_ENTITY_NOT_FINISHED => 37; use constant ERR_LT_IN_ATTRIBUTE => 38; use constant ERR_ATTRIBUTE_NOT_STARTED => 39; use constant ERR_ATTRIBUTE_NOT_FINISHED => 40; use constant ERR_ATTRIBUTE_WITHOUT_VALUE => 41; use constant ERR_ATTRIBUTE_REDEFINED => 42; use constant ERR_LITERAL_NOT_STARTED => 43; use constant ERR_LITERAL_NOT_FINISHED => 44; use constant ERR_COMMENT_NOT_FINISHED => 45; use constant ERR_PI_NOT_STARTED => 46; use constant ERR_PI_NOT_FINISHED => 47; use constant ERR_NOTATION_NOT_STARTED => 48; use constant ERR_NOTATION_NOT_FINISHED => 49; use constant ERR_ATTLIST_NOT_STARTED => 50; use constant ERR_ATTLIST_NOT_FINISHED => 51; use constant ERR_MIXED_NOT_STARTED => 52; use constant ERR_MIXED_NOT_FINISHED => 53; use constant ERR_ELEMCONTENT_NOT_STARTED => 54; use constant ERR_ELEMCONTENT_NOT_FINISHED => 55; use constant ERR_XMLDECL_NOT_STARTED => 56; use constant ERR_XMLDECL_NOT_FINISHED => 57; use constant ERR_CONDSEC_NOT_STARTED => 58; use constant ERR_CONDSEC_NOT_FINISHED => 59; use constant ERR_EXT_SUBSET_NOT_FINISHED => 60; use constant ERR_DOCTYPE_NOT_FINISHED => 61; use constant ERR_MISPLACED_CDATA_END => 62; use constant ERR_CDATA_NOT_FINISHED => 63; use constant ERR_RESERVED_XML_NAME => 64; use constant ERR_SPACE_REQUIRED => 65; use constant ERR_SEPARATOR_REQUIRED => 66; use constant ERR_NMTOKEN_REQUIRED => 67; use constant ERR_NAME_REQUIRED => 68; use constant ERR_PCDATA_REQUIRED => 69; use constant ERR_URI_REQUIRED => 70; use constant ERR_PUBID_REQUIRED => 71; use constant ERR_LT_REQUIRED => 72; use constant ERR_GT_REQUIRED => 73; use constant ERR_LTSLASH_REQUIRED => 74; use constant ERR_EQUAL_REQUIRED => 75; use constant ERR_TAG_NAME_MISMATCH => 76; use constant ERR_TAG_NOT_FINISHED => 77; use constant ERR_STANDALONE_VALUE => 78; use constant ERR_ENCODING_NAME => 79; use constant ERR_HYPHEN_IN_COMMENT => 80; use constant ERR_INVALID_ENCODING => 81; use constant ERR_EXT_ENTITY_STANDALONE => 82; use constant ERR_CONDSEC_INVALID => 83; use constant ERR_VALUE_REQUIRED => 84; use constant ERR_NOT_WELL_BALANCED => 85; use constant ERR_EXTRA_CONTENT => 86; use constant ERR_ENTITY_CHAR_ERROR => 87; use constant ERR_ENTITY_PE_INTERNAL => 88; use constant ERR_ENTITY_LOOP => 89; use constant ERR_ENTITY_BOUNDARY => 90; use constant ERR_INVALID_URI => 91; use constant ERR_URI_FRAGMENT => 92; use constant WAR_CATALOG_PI => 93; use constant ERR_NO_DTD => 94; use constant ERR_CONDSEC_INVALID_KEYWORD => 95; use constant ERR_VERSION_MISSING => 96; use constant WAR_UNKNOWN_VERSION => 97; use constant WAR_LANG_VALUE => 98; use constant WAR_NS_URI => 99; use constant WAR_NS_URI_RELATIVE => 100; use constant NS_ERR_XML_NAMESPACE => 200; use constant NS_ERR_UNDEFINED_NAMESPACE => 201; use constant NS_ERR_QNAME => 202; use constant NS_ERR_ATTRIBUTE_REDEFINED => 203; use constant DTD_ATTRIBUTE_DEFAULT => 500; use constant DTD_ATTRIBUTE_REDEFINED => 501; use constant DTD_ATTRIBUTE_VALUE => 502; use constant DTD_CONTENT_ERROR => 503; use constant DTD_CONTENT_MODEL => 504; use constant DTD_CONTENT_NOT_DETERMINIST => 505; use constant DTD_DIFFERENT_PREFIX => 506; use constant DTD_ELEM_DEFAULT_NAMESPACE => 507; use constant DTD_ELEM_NAMESPACE => 508; use constant DTD_ELEM_REDEFINED => 509; use constant DTD_EMPTY_NOTATION => 510; use constant DTD_ENTITY_TYPE => 511; use constant DTD_ID_FIXED => 512; use constant DTD_ID_REDEFINED => 513; use constant DTD_ID_SUBSET => 514; use constant DTD_INVALID_CHILD => 515; use constant DTD_INVALID_DEFAULT => 516; use constant DTD_LOAD_ERROR => 517; use constant DTD_MISSING_ATTRIBUTE => 518; use constant DTD_MIXED_CORRUPT => 519; use constant DTD_MULTIPLE_ID => 520; use constant DTD_NO_DOC => 521; use constant DTD_NO_DTD => 522; use constant DTD_NO_ELEM_NAME => 523; use constant DTD_NO_PREFIX => 524; use constant DTD_NO_ROOT => 525; use constant DTD_NOTATION_REDEFINED => 526; use constant DTD_NOTATION_VALUE => 527; use constant DTD_NOT_EMPTY => 528; use constant DTD_NOT_PCDATA => 529; use constant DTD_NOT_STANDALONE => 530; use constant DTD_ROOT_NAME => 531; use constant DTD_STANDALONE_WHITE_SPACE => 532; use constant DTD_UNKNOWN_ATTRIBUTE => 533; use constant DTD_UNKNOWN_ELEM => 534; use constant DTD_UNKNOWN_ENTITY => 535; use constant DTD_UNKNOWN_ID => 536; use constant DTD_UNKNOWN_NOTATION => 537; use constant HTML_STRUCURE_ERROR => 800; use constant HTML_UNKNOWN_TAG => 801; use constant RNGP_ANYNAME_ATTR_ANCESTOR => 1000; use constant RNGP_ATTR_CONFLICT => 1001; use constant RNGP_ATTRIBUTE_CHILDREN => 1002; use constant RNGP_ATTRIBUTE_CONTENT => 1003; use constant RNGP_ATTRIBUTE_EMPTY => 1004; use constant RNGP_ATTRIBUTE_NOOP => 1005; use constant RNGP_CHOICE_CONTENT => 1006; use constant RNGP_CHOICE_EMPTY => 1007; use constant RNGP_CREATE_FAILURE => 1008; use constant RNGP_DATA_CONTENT => 1009; use constant RNGP_DEF_CHOICE_AND_INTERLEAVE => 1010; use constant RNGP_DEFINE_CREATE_FAILED => 1011; use constant RNGP_DEFINE_EMPTY => 1012; use constant RNGP_DEFINE_MISSING => 1013; use constant RNGP_DEFINE_NAME_MISSING => 1014; use constant RNGP_ELEM_CONTENT_EMPTY => 1015; use constant RNGP_ELEM_CONTENT_ERROR => 1016; use constant RNGP_ELEMENT_EMPTY => 1017; use constant RNGP_ELEMENT_CONTENT => 1018; use constant RNGP_ELEMENT_NAME => 1019; use constant RNGP_ELEMENT_NO_CONTENT => 1020; use constant RNGP_ELEM_TEXT_CONFLICT => 1021; use constant RNGP_EMPTY => 1022; use constant RNGP_EMPTY_CONSTRUCT => 1023; use constant RNGP_EMPTY_CONTENT => 1024; use constant RNGP_EMPTY_NOT_EMPTY => 1025; use constant RNGP_ERROR_TYPE_LIB => 1026; use constant RNGP_EXCEPT_EMPTY => 1027; use constant RNGP_EXCEPT_MISSING => 1028; use constant RNGP_EXCEPT_MULTIPLE => 1029; use constant RNGP_EXCEPT_NO_CONTENT => 1030; use constant RNGP_EXTERNALREF_EMTPY => 1031; use constant RNGP_EXTERNAL_REF_FAILURE => 1032; use constant RNGP_EXTERNALREF_RECURSE => 1033; use constant RNGP_FORBIDDEN_ATTRIBUTE => 1034; use constant RNGP_FOREIGN_ELEMENT => 1035; use constant RNGP_GRAMMAR_CONTENT => 1036; use constant RNGP_GRAMMAR_EMPTY => 1037; use constant RNGP_GRAMMAR_MISSING => 1038; use constant RNGP_GRAMMAR_NO_START => 1039; use constant RNGP_GROUP_ATTR_CONFLICT => 1040; use constant RNGP_HREF_ERROR => 1041; use constant RNGP_INCLUDE_EMPTY => 1042; use constant RNGP_INCLUDE_FAILURE => 1043; use constant RNGP_INCLUDE_RECURSE => 1044; use constant RNGP_INTERLEAVE_ADD => 1045; use constant RNGP_INTERLEAVE_CREATE_FAILED => 1046; use constant RNGP_INTERLEAVE_EMPTY => 1047; use constant RNGP_INTERLEAVE_NO_CONTENT => 1048; use constant RNGP_INVALID_DEFINE_NAME => 1049; use constant RNGP_INVALID_URI => 1050; use constant RNGP_INVALID_VALUE => 1051; use constant RNGP_MISSING_HREF => 1052; use constant RNGP_NAME_MISSING => 1053; use constant RNGP_NEED_COMBINE => 1054; use constant RNGP_NOTALLOWED_NOT_EMPTY => 1055; use constant RNGP_NSNAME_ATTR_ANCESTOR => 1056; use constant RNGP_NSNAME_NO_NS => 1057; use constant RNGP_PARAM_FORBIDDEN => 1058; use constant RNGP_PARAM_NAME_MISSING => 1059; use constant RNGP_PARENTREF_CREATE_FAILED => 1060; use constant RNGP_PARENTREF_NAME_INVALID => 1061; use constant RNGP_PARENTREF_NO_NAME => 1062; use constant RNGP_PARENTREF_NO_PARENT => 1063; use constant RNGP_PARENTREF_NOT_EMPTY => 1064; use constant RNGP_PARSE_ERROR => 1065; use constant RNGP_PAT_ANYNAME_EXCEPT_ANYNAME => 1066; use constant RNGP_PAT_ATTR_ATTR => 1067; use constant RNGP_PAT_ATTR_ELEM => 1068; use constant RNGP_PAT_DATA_EXCEPT_ATTR => 1069; use constant RNGP_PAT_DATA_EXCEPT_ELEM => 1070; use constant RNGP_PAT_DATA_EXCEPT_EMPTY => 1071; use constant RNGP_PAT_DATA_EXCEPT_GROUP => 1072; use constant RNGP_PAT_DATA_EXCEPT_INTERLEAVE => 1073; use constant RNGP_PAT_DATA_EXCEPT_LIST => 1074; use constant RNGP_PAT_DATA_EXCEPT_ONEMORE => 1075; use constant RNGP_PAT_DATA_EXCEPT_REF => 1076; use constant RNGP_PAT_DATA_EXCEPT_TEXT => 1077; use constant RNGP_PAT_LIST_ATTR => 1078; use constant RNGP_PAT_LIST_ELEM => 1079; use constant RNGP_PAT_LIST_INTERLEAVE => 1080; use constant RNGP_PAT_LIST_LIST => 1081; use constant RNGP_PAT_LIST_REF => 1082; use constant RNGP_PAT_LIST_TEXT => 1083; use constant RNGP_PAT_NSNAME_EXCEPT_ANYNAME => 1084; use constant RNGP_PAT_NSNAME_EXCEPT_NSNAME => 1085; use constant RNGP_PAT_ONEMORE_GROUP_ATTR => 1086; use constant RNGP_PAT_ONEMORE_INTERLEAVE_ATTR => 1087; use constant RNGP_PAT_START_ATTR => 1088; use constant RNGP_PAT_START_DATA => 1089; use constant RNGP_PAT_START_EMPTY => 1090; use constant RNGP_PAT_START_GROUP => 1091; use constant RNGP_PAT_START_INTERLEAVE => 1092; use constant RNGP_PAT_START_LIST => 1093; use constant RNGP_PAT_START_ONEMORE => 1094; use constant RNGP_PAT_START_TEXT => 1095; use constant RNGP_PAT_START_VALUE => 1096; use constant RNGP_PREFIX_UNDEFINED => 1097; use constant RNGP_REF_CREATE_FAILED => 1098; use constant RNGP_REF_CYCLE => 1099; use constant RNGP_REF_NAME_INVALID => 1100; use constant RNGP_REF_NO_DEF => 1101; use constant RNGP_REF_NO_NAME => 1102; use constant RNGP_REF_NOT_EMPTY => 1103; use constant RNGP_START_CHOICE_AND_INTERLEAVE => 1104; use constant RNGP_START_CONTENT => 1105; use constant RNGP_START_EMPTY => 1106; use constant RNGP_START_MISSING => 1107; use constant RNGP_TEXT_EXPECTED => 1108; use constant RNGP_TEXT_HAS_CHILD => 1109; use constant RNGP_TYPE_MISSING => 1110; use constant RNGP_TYPE_NOT_FOUND => 1111; use constant RNGP_TYPE_VALUE => 1112; use constant RNGP_UNKNOWN_ATTRIBUTE => 1113; use constant RNGP_UNKNOWN_COMBINE => 1114; use constant RNGP_UNKNOWN_CONSTRUCT => 1115; use constant RNGP_UNKNOWN_TYPE_LIB => 1116; use constant RNGP_URI_FRAGMENT => 1117; use constant RNGP_URI_NOT_ABSOLUTE => 1118; use constant RNGP_VALUE_EMPTY => 1119; use constant RNGP_VALUE_NO_CONTENT => 1120; use constant RNGP_XMLNS_NAME => 1121; use constant RNGP_XML_NS => 1122; use constant XPATH_EXPRESSION_OK => 1200; use constant XPATH_NUMBER_ERROR => 1201; use constant XPATH_UNFINISHED_LITERAL_ERROR => 1202; use constant XPATH_START_LITERAL_ERROR => 1203; use constant XPATH_VARIABLE_REF_ERROR => 1204; use constant XPATH_UNDEF_VARIABLE_ERROR => 1205; use constant XPATH_INVALID_PREDICATE_ERROR => 1206; use constant XPATH_EXPR_ERROR => 1207; use constant XPATH_UNCLOSED_ERROR => 1208; use constant XPATH_UNKNOWN_FUNC_ERROR => 1209; use constant XPATH_INVALID_OPERAND => 1210; use constant XPATH_INVALID_TYPE => 1211; use constant XPATH_INVALID_ARITY => 1212; use constant XPATH_INVALID_CTXT_SIZE => 1213; use constant XPATH_INVALID_CTXT_POSITION => 1214; use constant XPATH_MEMORY_ERROR => 1215; use constant XPTR_SYNTAX_ERROR => 1216; use constant XPTR_RESOURCE_ERROR => 1217; use constant XPTR_SUB_RESOURCE_ERROR => 1218; use constant XPATH_UNDEF_PREFIX_ERROR => 1219; use constant XPATH_ENCODING_ERROR => 1220; use constant XPATH_INVALID_CHAR_ERROR => 1221; use constant TREE_INVALID_HEX => 1300; use constant TREE_INVALID_DEC => 1301; use constant TREE_UNTERMINATED_ENTITY => 1302; use constant SAVE_NOT_UTF8 => 1400; use constant SAVE_CHAR_INVALID => 1401; use constant SAVE_NO_DOCTYPE => 1402; use constant SAVE_UNKNOWN_ENCODING => 1403; use constant REGEXP_COMPILE_ERROR => 1450; use constant IO_UNKNOWN => 1500; use constant IO_EACCES => 1501; use constant IO_EAGAIN => 1502; use constant IO_EBADF => 1503; use constant IO_EBADMSG => 1504; use constant IO_EBUSY => 1505; use constant IO_ECANCELED => 1506; use constant IO_ECHILD => 1507; use constant IO_EDEADLK => 1508; use constant IO_EDOM => 1509; use constant IO_EEXIST => 1510; use constant IO_EFAULT => 1511; use constant IO_EFBIG => 1512; use constant IO_EINPROGRESS => 1513; use constant IO_EINTR => 1514; use constant IO_EINVAL => 1515; use constant IO_EIO => 1516; use constant IO_EISDIR => 1517; use constant IO_EMFILE => 1518; use constant IO_EMLINK => 1519; use constant IO_EMSGSIZE => 1520; use constant IO_ENAMETOOLONG => 1521; use constant IO_ENFILE => 1522; use constant IO_ENODEV => 1523; use constant IO_ENOENT => 1524; use constant IO_ENOEXEC => 1525; use constant IO_ENOLCK => 1526; use constant IO_ENOMEM => 1527; use constant IO_ENOSPC => 1528; use constant IO_ENOSYS => 1529; use constant IO_ENOTDIR => 1530; use constant IO_ENOTEMPTY => 1531; use constant IO_ENOTSUP => 1532; use constant IO_ENOTTY => 1533; use constant IO_ENXIO => 1534; use constant IO_EPERM => 1535; use constant IO_EPIPE => 1536; use constant IO_ERANGE => 1537; use constant IO_EROFS => 1538; use constant IO_ESPIPE => 1539; use constant IO_ESRCH => 1540; use constant IO_ETIMEDOUT => 1541; use constant IO_EXDEV => 1542; use constant IO_NETWORK_ATTEMPT => 1543; use constant IO_ENCODER => 1544; use constant IO_FLUSH => 1545; use constant IO_WRITE => 1546; use constant IO_NO_INPUT => 1547; use constant IO_BUFFER_FULL => 1548; use constant IO_LOAD_ERROR => 1549; use constant IO_ENOTSOCK => 1550; use constant IO_EISCONN => 1551; use constant IO_ECONNREFUSED => 1552; use constant IO_ENETUNREACH => 1553; use constant IO_EADDRINUSE => 1554; use constant IO_EALREADY => 1555; use constant IO_EAFNOSUPPORT => 1556; use constant XINCLUDE_RECURSION => 1600; use constant XINCLUDE_PARSE_VALUE => 1601; use constant XINCLUDE_ENTITY_DEF_MISMATCH => 1602; use constant XINCLUDE_NO_HREF => 1603; use constant XINCLUDE_NO_FALLBACK => 1604; use constant XINCLUDE_HREF_URI => 1605; use constant XINCLUDE_TEXT_FRAGMENT => 1606; use constant XINCLUDE_TEXT_DOCUMENT => 1607; use constant XINCLUDE_INVALID_CHAR => 1608; use constant XINCLUDE_BUILD_FAILED => 1609; use constant XINCLUDE_UNKNOWN_ENCODING => 1610; use constant XINCLUDE_MULTIPLE_ROOT => 1611; use constant XINCLUDE_XPTR_FAILED => 1612; use constant XINCLUDE_XPTR_RESULT => 1613; use constant XINCLUDE_INCLUDE_IN_INCLUDE => 1614; use constant XINCLUDE_FALLBACKS_IN_INCLUDE => 1615; use constant XINCLUDE_FALLBACK_NOT_IN_INCLUDE => 1616; use constant CATALOG_MISSING_ATTR => 1650; use constant CATALOG_ENTRY_BROKEN => 1651; use constant CATALOG_PREFER_VALUE => 1652; use constant CATALOG_NOT_CATALOG => 1653; use constant CATALOG_RECURSION => 1654; use constant SCHEMAP_PREFIX_UNDEFINED => 1700; use constant SCHEMAP_ATTRFORMDEFAULT_VALUE => 1701; use constant SCHEMAP_ATTRGRP_NONAME_NOREF => 1702; use constant SCHEMAP_ATTR_NONAME_NOREF => 1703; use constant SCHEMAP_COMPLEXTYPE_NONAME_NOREF => 1704; use constant SCHEMAP_ELEMFORMDEFAULT_VALUE => 1705; use constant SCHEMAP_ELEM_NONAME_NOREF => 1706; use constant SCHEMAP_EXTENSION_NO_BASE => 1707; use constant SCHEMAP_FACET_NO_VALUE => 1708; use constant SCHEMAP_FAILED_BUILD_IMPORT => 1709; use constant SCHEMAP_GROUP_NONAME_NOREF => 1710; use constant SCHEMAP_IMPORT_NAMESPACE_NOT_URI => 1711; use constant SCHEMAP_IMPORT_REDEFINE_NSNAME => 1712; use constant SCHEMAP_IMPORT_SCHEMA_NOT_URI => 1713; use constant SCHEMAP_INVALID_BOOLEAN => 1714; use constant SCHEMAP_INVALID_ENUM => 1715; use constant SCHEMAP_INVALID_FACET => 1716; use constant SCHEMAP_INVALID_FACET_VALUE => 1717; use constant SCHEMAP_INVALID_MAXOCCURS => 1718; use constant SCHEMAP_INVALID_MINOCCURS => 1719; use constant SCHEMAP_INVALID_REF_AND_SUBTYPE => 1720; use constant SCHEMAP_INVALID_WHITE_SPACE => 1721; use constant SCHEMAP_NOATTR_NOREF => 1722; use constant SCHEMAP_NOTATION_NO_NAME => 1723; use constant SCHEMAP_NOTYPE_NOREF => 1724; use constant SCHEMAP_REF_AND_SUBTYPE => 1725; use constant SCHEMAP_RESTRICTION_NONAME_NOREF => 1726; use constant SCHEMAP_SIMPLETYPE_NONAME => 1727; use constant SCHEMAP_TYPE_AND_SUBTYPE => 1728; use constant SCHEMAP_UNKNOWN_ALL_CHILD => 1729; use constant SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD => 1730; use constant SCHEMAP_UNKNOWN_ATTR_CHILD => 1731; use constant SCHEMAP_UNKNOWN_ATTRGRP_CHILD => 1732; use constant SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP => 1733; use constant SCHEMAP_UNKNOWN_BASE_TYPE => 1734; use constant SCHEMAP_UNKNOWN_CHOICE_CHILD => 1735; use constant SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD => 1736; use constant SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD => 1737; use constant SCHEMAP_UNKNOWN_ELEM_CHILD => 1738; use constant SCHEMAP_UNKNOWN_EXTENSION_CHILD => 1739; use constant SCHEMAP_UNKNOWN_FACET_CHILD => 1740; use constant SCHEMAP_UNKNOWN_FACET_TYPE => 1741; use constant SCHEMAP_UNKNOWN_GROUP_CHILD => 1742; use constant SCHEMAP_UNKNOWN_IMPORT_CHILD => 1743; use constant SCHEMAP_UNKNOWN_LIST_CHILD => 1744; use constant SCHEMAP_UNKNOWN_NOTATION_CHILD => 1745; use constant SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD => 1746; use constant SCHEMAP_UNKNOWN_REF => 1747; use constant SCHEMAP_UNKNOWN_RESTRICTION_CHILD => 1748; use constant SCHEMAP_UNKNOWN_SCHEMAS_CHILD => 1749; use constant SCHEMAP_UNKNOWN_SEQUENCE_CHILD => 1750; use constant SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD => 1751; use constant SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD => 1752; use constant SCHEMAP_UNKNOWN_TYPE => 1753; use constant SCHEMAP_UNKNOWN_UNION_CHILD => 1754; use constant SCHEMAP_ELEM_DEFAULT_FIXED => 1755; use constant SCHEMAP_REGEXP_INVALID => 1756; use constant SCHEMAP_FAILED_LOAD => 1756; use constant SCHEMAP_NOTHING_TO_PARSE => 1757; use constant SCHEMAP_NOROOT => 1758; use constant SCHEMAP_REDEFINED_GROUP => 1759; use constant SCHEMAP_REDEFINED_TYPE => 1760; use constant SCHEMAP_REDEFINED_ELEMENT => 1761; use constant SCHEMAP_REDEFINED_ATTRGROUP => 1762; use constant SCHEMAP_REDEFINED_ATTR => 1763; use constant SCHEMAP_REDEFINED_NOTATION => 1764; use constant SCHEMAP_FAILED_PARSE => 1765; use constant SCHEMAV_NOROOT => 1800; use constant SCHEMAV_UNDECLAREDELEM => 1801; use constant SCHEMAV_NOTTOPLEVEL => 1802; use constant SCHEMAV_MISSING => 1803; use constant SCHEMAV_WRONGELEM => 1804; use constant SCHEMAV_NOTYPE => 1805; use constant SCHEMAV_NOROLLBACK => 1806; use constant SCHEMAV_ISABSTRACT => 1807; use constant SCHEMAV_NOTEMPTY => 1808; use constant SCHEMAV_ELEMCONT => 1809; use constant SCHEMAV_HAVEDEFAULT => 1810; use constant SCHEMAV_NOTNILLABLE => 1811; use constant SCHEMAV_EXTRACONTENT => 1812; use constant SCHEMAV_INVALIDATTR => 1813; use constant SCHEMAV_INVALIDELEM => 1814; use constant SCHEMAV_NOTDETERMINIST => 1815; use constant SCHEMAV_CONSTRUCT => 1816; use constant SCHEMAV_INTERNAL => 1817; use constant SCHEMAV_NOTSIMPLE => 1818; use constant SCHEMAV_ATTRUNKNOWN => 1819; use constant SCHEMAV_ATTRINVALID => 1820; use constant SCHEMAV_VALUE => 1821; use constant SCHEMAV_FACET => 1822; use constant XPTR_UNKNOWN_SCHEME => 1900; use constant XPTR_CHILDSEQ_START => 1901; use constant XPTR_EVAL_FAILED => 1902; use constant XPTR_EXTRA_OBJECTS => 1903; use constant C14N_CREATE_CTXT => 1950; use constant C14N_REQUIRES_UTF8 => 1951; use constant C14N_CREATE_STACK => 1952; use constant C14N_INVALID_NODE => 1953; use constant FTP_PASV_ANSWER => 2000; use constant FTP_EPSV_ANSWER => 2001; use constant FTP_ACCNT => 2002; use constant HTTP_URL_SYNTAX => 2020; use constant HTTP_USE_IP => 2021; use constant HTTP_UNKNOWN_HOST => 2022; 1; PKM]EgLibXML/XPathExpression.podnu6$=head1 NAME XML::LibXML::XPathExpression - XML::LibXML::XPathExpression - interface to libxml2 pre-compiled XPath expressions =head1 SYNOPSIS use XML::LibXML; my $compiled_xpath = XML::LibXML::XPathExpression->new('//foo[@bar="baz"][position()<4]'); # interface from XML::LibXML::Node my $result = $node->find($compiled_xpath); my @nodes = $node->findnodes($compiled_xpath); my $value = $node->findvalue($compiled_xpath); # interface from XML::LibXML::XPathContext my $result = $xpc->find($compiled_xpath,$node); my @nodes = $xpc->findnodes($compiled_xpath,$node); my $value = $xpc->findvalue($compiled_xpath,$node); $compiled = XML::LibXML::XPathExpression->new( xpath_string ); =head1 DESCRIPTION This is a perl interface to libxml2's pre-compiled XPath expressions. Pre-compiling an XPath expression can give in some performance benefit if the same XPath query is evaluated many times. C<<<<<< XML::LibXML::XPathExpression >>>>>> objects can be passed to all C<<<<<< find... >>>>>> functions C<<<<<< XML::LibXML >>>>>> that expect an XPath expression. =over 4 =item new() $compiled = XML::LibXML::XPathExpression->new( xpath_string ); The constructor takes an XPath 1.0 expression as a string and returns an object representing the pre-compiled expressions (the actual data structure is internal to libxml2). =back =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]u;..LibXML/XPathContext.podnu6$=head1 NAME XML::LibXML::XPathContext - XPath Evaluation =head1 SYNOPSIS my $xpc = XML::LibXML::XPathContext->new(); my $xpc = XML::LibXML::XPathContext->new($node); $xpc->registerNs($prefix, $namespace_uri) $xpc->unregisterNs($prefix) $uri = $xpc->lookupNs($prefix) $xpc->registerVarLookupFunc($callback, $data) $data = $xpc->getVarLookupData(); $callback = $xpc->getVarLookupFunc(); $xpc->unregisterVarLookupFunc($name); $xpc->registerFunctionNS($name, $uri, $callback) $xpc->unregisterFunctionNS($name, $uri) $xpc->registerFunction($name, $callback) $xpc->unregisterFunction($name) @nodes = $xpc->findnodes($xpath_expression) @nodes = $xpc->findnodes($xpath_expression, $context_node ) $nodelist = $xpc->findnodes($xpath_expression, $context_node ) $object = $xpc->find($xpath_expression ) $object = $xpc->find($xpath_expression, $context_node ) $value = $xpc->findvalue($xpath_expression ) $value = $xpc->findvalue($xpath_expression, $context_node ) $bool = $xpc->exists( $xpath_expression, $context_node ); $xpc->setContextNode($node) my $node = $xpc->getContextNode; $xpc->setContextPosition($position) my $position = $xpc->getContextPosition; $xpc->setContextSize($size) my $size = $xpc->getContextSize; $xpc->setContextNode($node) =head1 DESCRIPTION The XML::LibXML::XPathContext class provides an almost complete interface to libxml2's XPath implementation. With XML::LibXML::XPathContext, it is possible to evaluate XPath expressions in the context of arbitrary node, context size, and context position, with a user-defined namespace-prefix mapping, custom XPath functions written in Perl, and even a custom XPath variable resolver. =head1 EXAMPLES =head2 Namespaces This example demonstrates C<<<<<< registerNs() >>>>>> method. It finds all paragraph nodes in an XHTML document. my $xc = XML::LibXML::XPathContext->new($xhtml_doc); $xc->registerNs('xhtml', 'http://www.w3.org/1999/xhtml'); my @nodes = $xc->findnodes('//xhtml:p'); =head2 Custom XPath functions This example demonstrates C<<<<<< registerFunction() >>>>>> method by defining a function filtering nodes based on a Perl regular expression: sub grep_nodes { my ($nodelist,$regexp) = @_; my $result = XML::LibXML::NodeList->new; for my $node ($nodelist->get_nodelist()) { $result->push($node) if $node->textContent =~ $regexp; } return $result; }; my $xc = XML::LibXML::XPathContext->new($node); $xc->registerFunction('grep_nodes', \&grep_nodes); my @nodes = $xc->findnodes('//section[grep_nodes(para,"\bsearch(ing|es)?\b")]'); =head2 Variables This example demonstrates C<<<<<< registerVarLookup() >>>>>> method. We use XPath variables to recycle results of previous evaluations: sub var_lookup { my ($varname,$ns,$data)=@_; return $data->{$varname}; } my $areas = XML::LibXML->new->parse_file('areas.xml'); my $empl = XML::LibXML->new->parse_file('employees.xml'); my $xc = XML::LibXML::XPathContext->new($empl); my %variables = ( A => $xc->find('/employees/employee[@salary>10000]'), B => $areas->find('/areas/area[district='Brooklyn']/street'), ); # get names of employees from $A working in an area listed in $B $xc->registerVarLookupFunc(\&var_lookup, \%variables); my @nodes = $xc->findnodes('$A[work_area/street = $B]/name'); =head1 METHODS =over 4 =item new my $xpc = XML::LibXML::XPathContext->new(); Creates a new XML::LibXML::XPathContext object without a context node. my $xpc = XML::LibXML::XPathContext->new($node); Creates a new XML::LibXML::XPathContext object with the context node set to C<<<<<< $node >>>>>>. =item registerNs $xpc->registerNs($prefix, $namespace_uri) Registers namespace C<<<<<< $prefix >>>>>> to C<<<<<< $namespace_uri >>>>>>. =item unregisterNs $xpc->unregisterNs($prefix) Unregisters namespace C<<<<<< $prefix >>>>>>. =item lookupNs $uri = $xpc->lookupNs($prefix) Returns namespace URI registered with C<<<<<< $prefix >>>>>>. If C<<<<<< $prefix >>>>>> is not registered to any namespace URI returns C<<<<<< undef >>>>>>. =item registerVarLookupFunc $xpc->registerVarLookupFunc($callback, $data) Registers variable lookup function C<<<<<< $callback >>>>>>. The registered function is executed by the XPath engine each time an XPath variable is evaluated. It takes three arguments: C<<<<<< $data >>>>>>, variable name, and variable ns-URI and must return one value: a number or string or any C<<<<<< XML::LibXML:: >>>>>> object that can be a result of findnodes: Boolean, Literal, Number, Node (e.g. Document, Element, etc.), or NodeList. For convenience, simple (non-blessed) array references containing only L<<<<<< XML::LibXML::Node >>>>>> objects can be used instead of an L<<<<<< XML::LibXML::NodeList >>>>>>. =item getVarLookupData $data = $xpc->getVarLookupData(); Returns the data that have been associated with a variable lookup function during a previous call to C<<<<<< registerVarLookupFunc >>>>>>. =item getVarLookupFunc $callback = $xpc->getVarLookupFunc(); Returns the variable lookup function previously registered with C<<<<<< registerVarLookupFunc >>>>>>. =item unregisterVarLookupFunc $xpc->unregisterVarLookupFunc($name); Unregisters variable lookup function and the associated lookup data. =item registerFunctionNS $xpc->registerFunctionNS($name, $uri, $callback) Registers an extension function C<<<<<< $name >>>>>> in C<<<<<< $uri >>>>>> namespace. C<<<<<< $callback >>>>>> must be a CODE reference. The arguments of the callback function are either simple scalars or C<<<<<< XML::LibXML::* >>>>>> objects depending on the XPath argument types. The function is responsible for checking the argument number and types. Result of the callback code must be a single value of the following types: a simple scalar (number, string) or an arbitrary C<<<<<< XML::LibXML::* >>>>>> object that can be a result of findnodes: Boolean, Literal, Number, Node (e.g. Document, Element, etc.), or NodeList. For convenience, simple (non-blessed) array references containing only L<<<<<< XML::LibXML::Node >>>>>> objects can be used instead of a L<<<<<< XML::LibXML::NodeList >>>>>>. =item unregisterFunctionNS $xpc->unregisterFunctionNS($name, $uri) Unregisters extension function C<<<<<< $name >>>>>> in C<<<<<< $uri >>>>>> namespace. Has the same effect as passing C<<<<<< undef >>>>>> as C<<<<<< $callback >>>>>> to registerFunctionNS. =item registerFunction $xpc->registerFunction($name, $callback) Same as C<<<<<< registerFunctionNS >>>>>> but without a namespace. =item unregisterFunction $xpc->unregisterFunction($name) Same as C<<<<<< unregisterFunctionNS >>>>>> but without a namespace. =item findnodes @nodes = $xpc->findnodes($xpath_expression) @nodes = $xpc->findnodes($xpath_expression, $context_node ) $nodelist = $xpc->findnodes($xpath_expression, $context_node ) Performs the xpath statement on the current node and returns the result as an array. In scalar context, returns an L<<<<<< XML::LibXML::NodeList >>>>>> object. Optionally, a node may be passed as a second argument to set the context node for the query. The xpath expression can be passed either as a string, or as a L<<<<<< XML::LibXML::XPathExpression >>>>>> object. =item find $object = $xpc->find($xpath_expression ) $object = $xpc->find($xpath_expression, $context_node ) Performs the xpath expression using the current node as the context of the expression, and returns the result depending on what type of result the XPath expression had. For example, the XPath C<<<<<< 1 * 3 + 52 >>>>>> results in an L<<<<<< XML::LibXML::Number >>>>>> object being returned. Other expressions might return a L<<<<<< XML::LibXML::Boolean >>>>>> object, or a L<<<<<< XML::LibXML::Literal >>>>>> object (a string). Each of those objects uses Perl's overload feature to ``do the right thing'' in different contexts. Optionally, a node may be passed as a second argument to set the context node for the query. The xpath expression can be passed either as a string, or as a L<<<<<< XML::LibXML::XPathExpression >>>>>> object. =item findvalue $value = $xpc->findvalue($xpath_expression ) $value = $xpc->findvalue($xpath_expression, $context_node ) Is exactly equivalent to: $xpc->find( $xpath_expression, $context_node )->to_literal; That is, it returns the literal value of the results. This enables you to ensure that you get a string back from your search, allowing certain shortcuts. This could be used as the equivalent of . Optionally, a node may be passed in the second argument to set the context node for the query. The xpath expression can be passed either as a string, or as a L<<<<<< XML::LibXML::XPathExpression >>>>>> object. =item exists $bool = $xpc->exists( $xpath_expression, $context_node ); This method behaves like I<<<<<< findnodes >>>>>>, except that it only returns a boolean value (1 if the expression matches a node, 0 otherwise) and may be faster than I<<<<<< findnodes >>>>>>, because the XPath evaluation may stop early on the first match (this is true for libxml2 >= 2.6.27). For XPath expressions that do not return node-set, the method returns true if the returned value is a non-zero number or a non-empty string. =item setContextNode $xpc->setContextNode($node) Set the current context node. =item getContextNode my $node = $xpc->getContextNode; Get the current context node. =item setContextPosition $xpc->setContextPosition($position) Set the current context position. By default, this value is -1 (and evaluating XPath function C<<<<<< position() >>>>>> in the initial context raises an XPath error), but can be set to any value up to context size. This usually only serves to cheat the XPath engine to return given position when C<<<<<< position() >>>>>> XPath function is called. Setting this value to -1 restores the default behavior. =item getContextPosition my $position = $xpc->getContextPosition; Get the current context position. =item setContextSize $xpc->setContextSize($size) Set the current context size. By default, this value is -1 (and evaluating XPath function C<<<<<< last() >>>>>> in the initial context raises an XPath error), but can be set to any non-negative value. This usually only serves to cheat the XPath engine to return the given value when C<<<<<< last() >>>>>> XPath function is called. If context size is set to 0, position is automatically also set to 0. If context size is positive, position is automatically set to 1. Setting context size to -1 restores the default behavior. =item getContextSize my $size = $xpc->getContextSize; Get the current context size. =item setContextNode $xpc->setContextNode($node) Set the current context node. =back =head1 BUGS AND CAVEATS XML::LibXML::XPathContext objects I<<<<<< are >>>>>> reentrant, meaning that you can call methods of an XML::LibXML::XPathContext even from XPath extension functions registered with the same object or from a variable lookup function. On the other hand, you should rather avoid registering new extension functions, namespaces and a variable lookup function from within extension functions and a variable lookup function, unless you want to experience untested behavior. =head1 AUTHORS Ilya Martynov and Petr Pajas, based on XML::LibXML and XML::LibXSLT code by Matt Sergeant and Christian Glahn. =head1 HISTORICAL REMARK Prior to XML::LibXML 1.61 this module was distributed separately for maintenance reasons. =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]Kc^ ^ LibXML/RelaxNG.podnu6$=head1 NAME XML::LibXML::RelaxNG - RelaxNG Schema Validation =head1 SYNOPSIS use XML::LibXML; $doc = XML::LibXML->new->parse_file($url); $rngschema = XML::LibXML::RelaxNG->new( location => $filename_or_url, no_network => 1 ); $rngschema = XML::LibXML::RelaxNG->new( string => $xmlschemastring, no_network => 1 ); $rngschema = XML::LibXML::RelaxNG->new( DOM => $doc, no_network => 1 ); eval { $rngschema->validate( $doc ); }; =head1 DESCRIPTION The XML::LibXML::RelaxNG class is a tiny frontend to libxml2's RelaxNG implementation. Currently it supports only schema parsing and document validation. =head1 METHODS =over 4 =item new $rngschema = XML::LibXML::RelaxNG->new( location => $filename_or_url, no_network => 1 ); $rngschema = XML::LibXML::RelaxNG->new( string => $xmlschemastring, no_network => 1 ); $rngschema = XML::LibXML::RelaxNG->new( DOM => $doc, no_network => 1 ); The constructor of XML::LibXML::RelaxNG needs to be called with list of parameters. At least location, string or DOM parameter is required to specify source of schema. Optional parameter no_network set to 1 cause that parser would not access network and optional parameter recover set 1 cause that parser would not call die() on errors. It is important, that each schema only have a single source. The location parameter allows one to parse a schema from the filesystem or a (non-HTTPS) URL. The string parameter will parse the schema from the given XML string. The DOM parameter allows one to parse the schema from a pre-parsed L<<<<<< XML::LibXML::Document >>>>>>. Note that the constructor will die() if the schema does not meed the constraints of the RelaxNG specification. =item validate eval { $rngschema->validate( $doc ); }; This function allows one to validate a (parsed) document against the given RelaxNG schema. The argument of this function should be an XML::LibXML::Document object. If this function succeeds, it will return 0, otherwise it will die() and report the errors found. Because of this validate() should be always evaluated. =back =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]#( ZLibXML/Text.podnu6$=head1 NAME XML::LibXML::Text - XML::LibXML Class for Text Nodes =head1 SYNOPSIS use XML::LibXML; # Only methods specific to Text nodes are listed here, # see the XML::LibXML::Node manpage for other methods $text = XML::LibXML::Text->new( $content ); $nodedata = $text->data; $text->setData( $text_content ); $text->substringData($offset, $length); $text->appendData( $somedata ); $text->insertData($offset, $string); $text->deleteData($offset, $length); $text->deleteDataString($remstring, $all); $text->replaceData($offset, $length, $string); $text->replaceDataString($old, $new, $flag); $text->replaceDataRegEx( $search_cond, $replace_cond, $reflags ); =head1 DESCRIPTION Unlike the DOM specification, XML::LibXML implements the text node as the base class of all character data node. Therefore there exists no CharacterData class. This allows one to apply methods of text nodes also to Comments and CDATA-sections. =head1 METHODS The class inherits from L<<<<<< XML::LibXML::Node >>>>>>. The documentation for Inherited methods is not listed here. Many functions listed here are extensively documented in the DOM Level 3 specification (L<<<<<< http://www.w3.org/TR/DOM-Level-3-Core/ >>>>>>). Please refer to the specification for extensive documentation. =over 4 =item new $text = XML::LibXML::Text->new( $content ); The constructor of the class. It creates an unbound text node. =item data $nodedata = $text->data; Although there exists the C<<<<<< nodeValue >>>>>> attribute in the Node class, the DOM specification defines data as a separate attribute. C<<<<<< XML::LibXML >>>>>> implements these two attributes not as different attributes, but as aliases, such as C<<<<<< libxml2 >>>>>> does. Therefore $text->data; and $text->nodeValue; will have the same result and are not different entities. =item setData($string) $text->setData( $text_content ); This function sets or replaces text content to a node. The node has to be of the type "text", "cdata" or "comment". =item substringData($offset,$length) $text->substringData($offset, $length); Extracts a range of data from the node. (DOM Spec) This function takes the two parameters $offset and $length and returns the sub-string, if available. If the node contains no data or $offset refers to an non-existing string index, this function will return I<<<<<< undef >>>>>>. If $length is out of range C<<<<<< substringData >>>>>> will return the data starting at $offset instead of causing an error. =item appendData($string) $text->appendData( $somedata ); Appends a string to the end of the existing data. If the current text node contains no data, this function has the same effect as C<<<<<< setData >>>>>>. =item insertData($offset,$string) $text->insertData($offset, $string); Inserts the parameter $string at the given $offset of the existing data of the node. This operation will not remove existing data, but change the order of the existing data. The $offset has to be a positive value. If $offset is out of range, C<<<<<< insertData >>>>>> will have the same behaviour as C<<<<<< appendData >>>>>>. =item deleteData($offset, $length) $text->deleteData($offset, $length); This method removes a chunk from the existing node data at the given offset. The $length parameter tells, how many characters should be removed from the string. =item deleteDataString($string, [$all]) $text->deleteDataString($remstring, $all); This method removes a chunk from the existing node data. Since the DOM spec is quite unhandy if you already know C<<<<<< which >>>>>> string to remove from a text node, this method allows more perlish code :) The functions takes two parameters: I<<<<<< $string >>>>>> and optional the I<<<<<< $all >>>>>> flag. If $all is not set, I<<<<<< undef >>>>>> or I<<<<<< 0 >>>>>>, C<<<<<< deleteDataString >>>>>> will remove only the first occurrence of $string. If $all is I<<<<<< TRUE >>>>>>C<<<<<< deleteDataString >>>>>> will remove all occurrences of I<<<<<< $string >>>>>> from the node data. =item replaceData($offset, $length, $string) $text->replaceData($offset, $length, $string); The DOM style version to replace node data. =item replaceDataString($oldstring, $newstring, [$all]) $text->replaceDataString($old, $new, $flag); The more programmer friendly version of replaceData() :) Instead of giving offsets and length one can specify the exact string (I<<<<<< $oldstring >>>>>>) to be replaced. Additionally the I<<<<<< $all >>>>>> flag allows one to replace all occurrences of I<<<<<< $oldstring >>>>>>. =item replaceDataRegEx( $search_cond, $replace_cond, $reflags ) $text->replaceDataRegEx( $search_cond, $replace_cond, $reflags ); This method replaces the node's data by a C<<<<<< simple >>>>>> regular expression. Optional, this function allows one to pass some flags that will be added as flag to the replace statement. I<<<<<< NOTE: >>>>>> This is a shortcut for my $datastr = $node->getData(); $datastr =~ s/somecond/replacement/g; # 'g' is just an example for any flag $node->setData( $datastr ); This function can make things easier to read for simple replacements. For more complex variants it is recommended to use the code snippet above. =back =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]OOLibXML/ErrNo.podnu6$=head1 NAME XML::LibXML::ErrNo - Structured Errors =head1 DESCRIPTION This module is based on xmlerror.h libxml2 C header file. It defines symbolic constants for all libxml2 error codes. Currently libxml2 uses over 480 different error codes. See also XML::LibXML::Error. =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]yyLibXML/Reader.pmnu6$# $Id: Reader.pm,v 1.1.2.1 2004/04/20 20:09:48 pajas Exp $ # # This is free software, you may use it and distribute it under the same terms as # Perl itself. # # Copyright 2001-2003 AxKit.com Ltd., 2002-2006 Christian Glahn, 2006-2009 Petr Pajas # # package XML::LibXML::Reader; use XML::LibXML; use Carp; use strict; use warnings; our $VERSION = "2.0213"; # VERSION TEMPLATE: DO NOT CHANGE use 5.008_000; BEGIN { UNIVERSAL::can('XML::LibXML::Reader','_newForFile') or croak("Cannot use XML::LibXML::Reader module - ". "your libxml2 is compiled without reader support!"); } use base qw(Exporter); use constant { XML_READER_TYPE_NONE => 0, XML_READER_TYPE_ELEMENT => 1, XML_READER_TYPE_ATTRIBUTE => 2, XML_READER_TYPE_TEXT => 3, XML_READER_TYPE_CDATA => 4, XML_READER_TYPE_ENTITY_REFERENCE => 5, XML_READER_TYPE_ENTITY => 6, XML_READER_TYPE_PROCESSING_INSTRUCTION => 7, XML_READER_TYPE_COMMENT => 8, XML_READER_TYPE_DOCUMENT => 9, XML_READER_TYPE_DOCUMENT_TYPE => 10, XML_READER_TYPE_DOCUMENT_FRAGMENT => 11, XML_READER_TYPE_NOTATION => 12, XML_READER_TYPE_WHITESPACE => 13, XML_READER_TYPE_SIGNIFICANT_WHITESPACE => 14, XML_READER_TYPE_END_ELEMENT => 15, XML_READER_TYPE_END_ENTITY => 16, XML_READER_TYPE_XML_DECLARATION => 17, XML_READER_NONE => -1, XML_READER_START => 0, XML_READER_ELEMENT => 1, XML_READER_END => 2, XML_READER_EMPTY => 3, XML_READER_BACKTRACK => 4, XML_READER_DONE => 5, XML_READER_ERROR => 6 }; sub CLONE_SKIP { 1 } BEGIN { our %EXPORT_TAGS = ( types => [qw( XML_READER_TYPE_NONE XML_READER_TYPE_ELEMENT XML_READER_TYPE_ATTRIBUTE XML_READER_TYPE_TEXT XML_READER_TYPE_CDATA XML_READER_TYPE_ENTITY_REFERENCE XML_READER_TYPE_ENTITY XML_READER_TYPE_PROCESSING_INSTRUCTION XML_READER_TYPE_COMMENT XML_READER_TYPE_DOCUMENT XML_READER_TYPE_DOCUMENT_TYPE XML_READER_TYPE_DOCUMENT_FRAGMENT XML_READER_TYPE_NOTATION XML_READER_TYPE_WHITESPACE XML_READER_TYPE_SIGNIFICANT_WHITESPACE XML_READER_TYPE_END_ELEMENT XML_READER_TYPE_END_ENTITY XML_READER_TYPE_XML_DECLARATION )], states => [qw( XML_READER_NONE XML_READER_START XML_READER_ELEMENT XML_READER_END XML_READER_EMPTY XML_READER_BACKTRACK XML_READER_DONE XML_READER_ERROR )] ); our @EXPORT = (@{$EXPORT_TAGS{types}},@{$EXPORT_TAGS{states}}); our @EXPORT_OK = @EXPORT; $EXPORT_TAGS{all}=\@EXPORT_OK; } our %_preserve_flag; { my %props = ( load_ext_dtd => 1, # load the external subset complete_attributes => 2, # default DTD attributes validation => 3, # validate with the DTD expand_entities => 4, # substitute entities ); sub getParserProp { my ($self, $name) = @_; my $prop = $props{$name}; return undef unless defined $prop; return $self->_getParserProp($prop); } sub setParserProp { my $self = shift; my %args = map { ref($_) eq 'HASH' ? (%$_) : $_ } @_; my ($key, $value); while (($key,$value) = each %args) { my $prop = $props{ $key }; $self->_setParserProp($prop,$value); } return; } my (%string_pool,%rng_pool,%xsd_pool); # used to preserve data passed to the reader sub new { my ($class) = shift; my %args = map { ref($_) eq 'HASH' ? (%$_) : $_ } @_; my $encoding = $args{encoding}; my $URI = $args{URI}; $URI="$URI" if defined $URI; # stringify in case it is an URI object my $options = XML::LibXML->_parser_options(\%args); my $self = undef; if ( defined $args{location} ) { $self = $class->_newForFile( $args{location}, $encoding, $options ); } elsif ( defined $args{string} ) { $self = $class->_newForString( $args{string}, $URI, $encoding, $options ); if (defined($self)) { $string_pool{$self} = \$args{string}; } } elsif ( defined $args{IO} ) { $self = $class->_newForIO( $args{IO}, $URI, $encoding, $options ); } elsif ( defined $args{DOM} ) { croak("DOM must be a XML::LibXML::Document node") unless UNIVERSAL::isa($args{DOM}, 'XML::LibXML::Document'); $self = $class->_newForDOM( $args{DOM} ); } elsif ( defined $args{FD} ) { my $fd = fileno($args{FD}); $self = $class->_newForFd( $fd, $URI, $encoding, $options ); } else { croak("XML::LibXML::Reader->new: specify location, string, IO, DOM, or FD"); } if ($args{RelaxNG}) { if (ref($args{RelaxNG})) { $rng_pool{$self} = \$args{RelaxNG}; $self->_setRelaxNG($args{RelaxNG}); } else { $self->_setRelaxNGFile($args{RelaxNG}); } } if ($args{Schema}) { if (ref($args{Schema})) { $xsd_pool{$self} = \$args{Schema}; $self->_setXSD($args{Schema}); } else { $self->_setXSDFile($args{Schema}); } } return $self; } sub DESTROY { my $self = shift; delete $string_pool{$self}; delete $rng_pool{$self}; delete $xsd_pool{$self}; $self->_DESTROY; } } sub close { my ($reader) = @_; # _close return -1 on failure, 0 on success # perl close returns 0 on failure, 1 on success return $reader->_close == 0 ? 1 : 0; } sub preservePattern { my $reader=shift; my ($pattern,$ns_map)=@_; if (ref($ns_map) eq 'HASH') { # translate prefix=>URL hash to a (URL,prefix) list $reader->_preservePattern($pattern,[reverse %$ns_map]); } else { $reader->_preservePattern(@_); } } sub nodePath { my $reader=shift; my $path = $reader->_nodePath; $path=~s/\[\d+\]//g; # make /foo[1]/bar[1] just /foo/bar, since # sibling count in the buffered fragment is # basically random and generally misleading return $path; } 1; __END__ PKM] ,,LibXML/Boolean.pmnu6$# $Id$ # # # This is free software, you may use it and distribute it under the same terms as # Perl itself. # # Copyright 2001-2003 AxKit.com Ltd., 2002-2006 Christian Glahn, 2006-2009 Petr Pajas # # package XML::LibXML::Boolean; use XML::LibXML::Number; use XML::LibXML::Literal; use strict; use warnings; our $VERSION = "2.0213"; # VERSION TEMPLATE: DO NOT CHANGE use overload '""' => \&value, '<=>' => \&cmp; sub new { my $class = shift; my ($param) = @_; my $val = $param ? 1 : 0; bless \$val, $class; } sub True { my $class = shift; my $val = 1; bless \$val, $class; } sub False { my $class = shift; my $val = 0; bless \$val, $class; } sub value { my $self = shift; $$self; } sub cmp { my $self = shift; my ($other, $swap) = @_; if ($swap) { return $other <=> $$self; } return $$self <=> $other; } sub to_number { XML::LibXML::Number->new($_[0]->value); } sub to_boolean { $_[0]; } sub to_literal { XML::LibXML::Literal->new($_[0]->value ? "true" : "false"); } sub string_value { return $_[0]->to_literal->value; } 1; __END__ =head1 NAME XML::LibXML::Boolean - Boolean true/false values =head1 DESCRIPTION XML::LibXML::Boolean objects implement simple boolean true/false objects. =head1 API =head2 XML::LibXML::Boolean->True Creates a new Boolean object with a true value. =head2 XML::LibXML::Boolean->False Creates a new Boolean object with a false value. =head2 value() Returns true or false. =head2 to_literal() Returns the string "true" or "false". =cut PKM]JhhLibXML/Number.pmnu6$# $Id$ # # This is free software, you may use it and distribute it under the same terms as # Perl itself. # # Copyright 2001-2003 AxKit.com Ltd., 2002-2006 Christian Glahn, 2006-2009 Petr Pajas # # package XML::LibXML::Number; use XML::LibXML::Boolean; use XML::LibXML::Literal; use strict; use warnings; our $VERSION = "2.0213"; # VERSION TEMPLATE: DO NOT CHANGE use overload '""' => \&value, '0+' => \&value, '<=>' => \&cmp; sub new { my $class = shift; my $number = shift; if ($number !~ /^\s*(-\s*)?(\d+(\.\d*)?|\.\d+)\s*$/) { $number = undef; } else { $number =~ s/\s+//g; } bless \$number, $class; } sub as_string { my $self = shift; defined $$self ? $$self : 'NaN'; } sub as_xml { my $self = shift; return "" . (defined($$self) ? $$self : 'NaN') . "\n"; } sub value { my $self = shift; $$self; } sub cmp { my $self = shift; my ($other, $swap) = @_; if ($swap) { return $other <=> $$self; } return $$self <=> $other; } sub evaluate { my $self = shift; $self; } sub to_boolean { my $self = shift; return $$self ? XML::LibXML::Boolean->True : XML::LibXML::Boolean->False; } sub to_literal { XML::LibXML::Literal->new($_[0]->as_string); } sub to_number { $_[0]; } sub string_value { return $_[0]->value } 1; __END__ =head1 NAME XML::LibXML::Number - Simple numeric values. =head1 DESCRIPTION This class holds simple numeric values. It doesn't support -0, +/- Infinity, or NaN, as the XPath spec says it should, but I'm not hurting anyone I don't think. =head1 API =head2 new($num) Creates a new XML::LibXML::Number object, with the value in $num. Does some rudimentary numeric checking on $num to ensure it actually is a number. =head2 value() Also as overloaded stringification. Returns the numeric value held. =cut PKM]s##LibXML/CDATASection.podnu6$=head1 NAME XML::LibXML::CDATASection - XML::LibXML Class for CDATA Sections =head1 SYNOPSIS use XML::LibXML; # Only methods specific to CDATA nodes are listed here, # see the XML::LibXML::Node manpage for other methods $node = XML::LibXML::CDATASection->new( $content ); =head1 DESCRIPTION This class provides all functions of L<<<<<< XML::LibXML::Text >>>>>>, but for CDATA nodes. =head1 METHODS The class inherits from L<<<<<< XML::LibXML::Node >>>>>>. The documentation for Inherited methods is not listed here. Many functions listed here are extensively documented in the DOM Level 3 specification (L<<<<<< http://www.w3.org/TR/DOM-Level-3-Core/ >>>>>>). Please refer to the specification for extensive documentation. =over 4 =item new $node = XML::LibXML::CDATASection->new( $content ); The constructor is the only provided function for this package. It is required, because I<<<<<< libxml2 >>>>>> treats the different text node types slightly differently. =back =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]o&&LibXML/RegExp.podnu6$=head1 NAME XML::LibXML::RegExp - XML::LibXML::RegExp - interface to libxml2 regular expressions =head1 SYNOPSIS use XML::LibXML; my $compiled_re = XML::LibXML::RegExp->new('[0-9]{5}(-[0-9]{4})?'); if ($compiled_re->isDeterministic()) { ... } if ($compiled_re->matches($string)) { ... } $compiled_re = XML::LibXML::RegExp->new( $regexp_str ); $bool = $compiled_re->matches($string); $bool = $compiled_re->isDeterministic(); =head1 DESCRIPTION This is a perl interface to libxml2's implementation of regular expressions, which are used e.g. for validation of XML Schema simple types (pattern facet). =over 4 =item new() $compiled_re = XML::LibXML::RegExp->new( $regexp_str ); The constructor takes a string containing a regular expression and returns a compiled regexp object. =item matches($string) $bool = $compiled_re->matches($string); Given a string value, returns a true value if the value is matched by the compiled regular expression. =item isDeterministic() $bool = $compiled_re->isDeterministic(); Returns a true value if the regular expression is deterministic; returns false otherwise. (See the definition of determinism in the XML spec (L<<<<<< http://www.w3.org/TR/REC-xml/#determinism >>>>>>)) =back =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]7u LibXML/PI.podnu6$=head1 NAME XML::LibXML::PI - XML::LibXML Processing Instructions =head1 SYNOPSIS use XML::LibXML; # Only methods specific to Processing Instruction nodes are listed here, # see the XML::LibXML::Node manpage for other methods $pinode->setData( $data_string ); $pinode->setData( name=>string_value [...] ); =head1 DESCRIPTION Processing instructions are implemented with XML::LibXML with read and write access. The PI data is the PI without the PI target (as specified in XML 1.0 [17]) as a string. This string can be accessed with getData as implemented in L<<<<<< XML::LibXML::Node >>>>>>. The write access is aware about the fact, that many processing instructions have attribute like data. Therefore setData() provides besides the DOM spec conform Interface to pass a set of named parameter. So the code segment my $pi = $dom->createProcessingInstruction("abc"); $pi->setData(foo=>'bar', foobar=>'foobar'); $dom->appendChild( $pi ); will result the following PI in the DOM: Which is how it is specified in the DOM specification. This three step interface creates temporary a node in perl space. This can be avoided while using the insertProcessingInstruction() method. Instead of the three calls described above, the call $dom->insertProcessingInstruction("abc",'foo="bar" foobar="foobar"'); will have the same result as above. L<<<<<< XML::LibXML::PI >>>>>>'s implementation of setData() documented below differs a bit from the standard version as available in L<<<<<< XML::LibXML::Node >>>>>>: =over 4 =item setData $pinode->setData( $data_string ); $pinode->setData( name=>string_value [...] ); This method allows one to change the content data of a PI. Additionally to the interface specified for DOM Level2, the method provides a named parameter interface to set the data. This parameter list is converted into a string before it is appended to the PI. =back =head1 AUTHORS Matt Sergeant, Christian Glahn, Petr Pajas =head1 VERSION 2.0213 =head1 COPYRIGHT 2001-2007, AxKit.com Ltd. 2002-2006, Christian Glahn. 2006-2009, Petr Pajas. =cut =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. PKM]/100Parser/Encodings/iso-8859-2.encnu6$ISO-8859-2  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~A=Z`^dy}{B>[a_ez~|T9 CGPXnpbU: DHQYoqcPKM]ؒ00Parser/Encodings/iso-8859-8.encnu6$ISO-8859-8  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ > PKM]W&Parser/Encodings/x-euc-jp-jisx0221.encnu6$X-EUC-JP-JISX02214A  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~g?gL?^^PCKSVL8Q +^K^^^e^^!^^^;^^^U^^^o^^ +^ ^ ^ E^ ^ ^ _^ ^ ^ y^ ^ 5^ ^ ^O3^^>^^^X^^^r^^.^^^H^^^b^^^|^^8^^^R^^^l^^(^^^B^^^\^~Ca=}0VWWA^^^T^^^n^^ *^ ^ ^!D^!^"^"^^"^#^#x^#^$4^$^$^%N^%^& ^&h^&^'$^'^'^(>^(^(^)X^)^*^*r^*^+.^+^+^,H^,^-^-b^-^.^.|^.^/8^/^/^0R^0^1^1l^1^2(^2^2^3B^3C3  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOabcdefghijklmnopqrstuvwxyz{|}~PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~000 000@>?00000N0000  \0 \ & %     00;=[]00 0 0 0 0 0000 ""`"f"g""4&B&@ 2 3! &&%%%%%%%%%%% ;0!!!!0"" """""*")"'"(!!""" "#"""a"R"j"k""=""5"+",!+ 0&o&m&j !%!"#$%&'()*+,-./0123456789:ABCDEFGHIJKLMNOPQRSTUVWXYZ0A0B0C0D0E0F0G0H0I0J0K0L0M0N0O0P0Q0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z0{0|0}0~00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 !"#$%&'()*+,-./012345Q6789:;<=>?@ABCDEFGHIJKLMNO%%% %%%%%,%$%4%<%%%%%%%#%3%+%;%K% %/%(%7%?%%0%%%8%BNUZ?Tac(Y"uzP`cn%efhW'ebq[YІ{}b}b|[^c fhHǗgONO OMOPIVY7YZ\ `aapfipuOupy}}ÄcUzS;NNW߀xNXn8z2(/QASpTTVY_m-bpT S[p–So\zNxn&VUk;YSmftܕVBNKO SU[0_qf fhl8lm)t[vzN4[`muvʙ`iSQWX0YD[^`(cclopqqYqs?~vх`[XielZu%QY.Ye__bej*k'ksV,\l{Q\KahvraNYOSx`in)zON SNOUO=OOsRSV YZ[[yfggkLlpksyyz<{ۃwӇfV)NO\brYu;傽řNOVXJX^_`*``babbe9AffhmwppuLv}uQRYT[]ahimxˈWrmlWgΒRVT^bdhkSlWo"ooEtuvw z{|!}6f̌Qeә(N8T+\]svLw<\ TXOOSqUVhWYG[ [\^ ^~_cg:eeghhj_^0kll}uyH[cz}_w̏Z/__`hjtZxwN^NO|OPPQIQlRRRSSTTUWQWY}[T[][]]]^x^^^_`RaLbbce;ffCfgmh!hil_m*min/nu2vxlz?|}}}^}T*RLaʑuqx?M؝;R[RSTXboj_QKR;TJVz@w`sDo pu_`ښrۏkdNVWdXZZ`haffh9hmu}:nBNOPSU]o]]gltsxPWP^c+PPQgTX^Y[_ibMch=ksnp}rxx&yme}0܈ RdW(gPjQWB*X:iT]WxO\RJTd>f(ggz{V}"/h\{9SQR7[bddg-kvcLvfRN PS\q`dech_qsu#{~ۑxefkNNO:OR:SSUVXYYY[P\M^^+_`ce/[\eeegkbk{lsEyIy|}}+󉖊^ifnjܖ̘koNOtuxy: 3ꄔlP_X+z[NSWY1Z[`nou[{Prg\aJ~Q\chfeqny>}ʐnǐPR\:gSp|r5Lȓ+[_1`N;S[bKg1krsz.kRQSTj[cj9}VSTh[\1]Oabm2yy}B~MҁFrt/1KlƑNOOQESA_bglAn sc~&͒SY[my]~.|X~qQSO\f%wzQ_eiokmnodv}]uQRb@ffn^}rfRSYs^_`UdPQRS SGSTUFU1VYhYZ<[\\\\^^^_pbbbccwff f-fvg~hjj5lmn nXq d_xRbcdBb-z{}v INQHSCS`[\\]b&bGdhh4lmEmgo\qNq}ez{}~Jz9n΍xwRMUo8q6Qhy~U|VLXQ\cffiZruuyyVy|} }D4;a PRuSSP UXYOr=[\dS``c\cc?cdef]iioqNuvz|}}aIXlōpmPXaӅ5 OPtRGSs`ocIg_n,O\^e}SRQvc[X[k\ d gQ\NYY*lpQU>XY`bSg5iU@Ě(OSX[\^/_` aKb4flnހ΁Ԉ.ۛNSY'{,Lnp'SSUD[bXbblot"8o8QSSOFTYj1]zꏿhڌ7rHj=N9SXVWfbcekNmn[pwz{}=Ɔˊ[VX_>efjku7P$wW0_`efzl`uznE{u\z{QĐyz6Zw@N-N[_bft6x4ZFuO^bceWgovrL̀)MP WZhisqdrXjyw)O/ReSZbglv}{|6fo r~Q{xr{{Hj^auQu`QkbnvzOpb{OVzXY䖼O4R$SJSS^d,egl>lNrHrsuT~A,錩{đqic=fiujvxЅCS*SQT&Y^_|`bIbybekluvxy}w^j |8P\>_gkt5w ;gzS9u_f_<_ub{Feg llpx2~+ނ *JҘlNONPRVWJY^=__b?fgghQ}!~2T ,SPS\Xdg4rgwfzFRlkX^LYTg,QvdixTWYf'gkTi^UggRh]NOSbg+lO~mNabno+Tsg*E]{\[ƇnJzY|lw RY"q!r_wۗ'ai ZZQT T}fvߏYr]nQMh}}bdxj!Y[_ksv}Q2g(vgbR\$b;|~UO`} SN_QYr:6_%wS_y}3Vg󅮔Sa alvR8U/OQQ*RS[^}`acg gngms6s7u1yPՊJćYNOYN?P^|Y[^ccdfiJim nqu(zIɉ! e} a~bk2lmtmge}o#,TBojp2RZA^_gi|imjorbr{~KQmy2P-Tqkjā`gNNkhin~xU_ NNN*N1N6NzYUYPYNYZYXYbY`YgYlYiYxYYO^OYYYYYYYYZ%ZZZZ ZZ@ZlZIZ5Z6ZbZjZZZZZZZZZZZZZ[ [ [[2Z[*[6[>[C[E[@[Q[U[Z[[[e[i[p[s[u[xe[z[[[[[[[[[[[[[[[[[[\\\\ \\ \"\(\8\9\A\F\N\S\P\O[q\l\nNb\v\y\\\Y\\\\\\\\\\\\\]\] ]]]\]]]]]"]]]]L]R]N]K]l]s]v]]]]]]]]]]]]]]]]]]]]^ ^^^^^6^7^D^C^@^N^W^T^_^b^d^G^u^v^z^^^^^^^^^^^^^^^^^^^^^^^__ _]_\_ ___)_-_8_A_H_L_N_/_Q_V_W_Y_a_m_s_w____________________`_`!`````)``1```+`&``:`Z`A`j`w`_`J`F`M`c`C`d`B`l`k`Y`````````````````_````aMaa``a``aa!``a aaGa>a(a'aJa?acMdcOcccccvcccccckcicccccccccdd4ddd&d6edd(ddgdodvdNe*ddddddddddddddd ddbdde,ddddedeeee$e#e+e4e5e7e6e8uKeHeVeUeMeXe^e]erexeeeeeeeeeeeeeeeeegrf fegsf5f6f4ffOfDfIfAf^f]fdfgfhf_fbfpffffffffffffffffff?fffffgggg&g'8g.g?g6gAg8g7gFg^g`gYgcgdggpgg|gjgggggggggggggggggggggjhhFh)h@hMh2hNhh+hYhchwhhhhhhhhjhhthhhihh~ihihi"i&hi hhhhi6iihhi%hhhi(i*ii#i!hiyiwi\ixikiTi~ini9iti=iYi0iai^i]iijiiiiiiii[iiiiij.iiiiiiijjik iiijijijij jjj#jjDj jrj6jxjGjbjYjfjHj8j"jjjjjjjjjjjjjjjjjjjjkjkk1kk8k7vk9kGkCkIkPkYkTk[k_kakxkykkkkkkkkkkkkkkkkkkkkkkkkklllll$l#l^lUlbljllllll~lhlslllllllllllllllllmMm6m+m=m8mm5m3mm mcmmdmZmymYmmommnn mmmmmmmmmmmmmmmmmn-nnn.nnrn_n>n#nkn+nvnMnnCn:nNn$nnn8nnnnnnnnnnnnnnnnoAopLnnno?no1no2no>onoozoxooooo[oomoo|oXoooofooooooooooooooop p opppoppotpppp0p>p2pQpcppppppppppppq pqqqeqUqqfqbqLqVqlqqqqqqqqqqqqqqqqqqqqr rrr(r-r,r0r2r;rsNsOsWsjshspsxsus{szsssssssstttot%st2t:tUt?t_tYtAt\titptctjtvt~ttttttsttttttttttuuuu uu uuuu&u,uz7zCzWzIzazbzizpzyz}zzzzzzzzzzzzzzzzzzzzzzzzzz{{{ {{3{{{{5{({6{P{z{{M{ {L{E{u{e{t{g{p{q{l{n{{{{{{{{{{]{{{{{{{{{||{{|`|||{{|| {|#|'|*||7|+|=|L|C|T|O|@|P|X|_|d|V|e|l|u|||||||||||||||||||||;|||||}}}}} }E}K}.}2}?}5}F}s}V}N}r}h}n}O}c}}}[}}}}}}}}}}}~=}}}}}}}}}}}}}~~ ~#~!~~1~~ ~ ~"~F~f~;~5~9~C~7~2~:~g~]~V~^~Y~Z~y~j~i~|~{~}~}~~~~~~~~~~~~8:ELMNPQUTX_`higxq܀ !(?;JFRXZ_bhsrpvy}Qۀـ݀Āڀց )#/KF>SQqneft_Ɂ́сف؁ȁځ߁ )+83@YX]Z_dbhjk.qwx~߂҂ރ܃ ك5421@9PE/+#|su΃؄  " 8m*(ALONIV[Zk_lot}:A?HLNPUblxz|bȌڌ  N͍gmqsύڍ֍̍ۍˍߍ B504JGILPHYd`*cUvr|ƎŎȎˎێ  &3;9EB>LIFNW\bcdڏ!  '659OPQRI>VX^hovr}bHۑ20JVXceisrɑˑБ֑ߑۑ,^WEIdH?KPZϒD."#:5;\`|nV֓דؓÓݓГȓ6+5!:ARD[`b^j)puw}Z|~oÕ͕̕Օԕ֕ܕ!(./BLOKw\^]_frlΖ˖ɖ͉Mܗ Ֆ$*09=>DFHBI\`dfhRҗkqy|z×Ɨȗ˗ܗOzߗ 8$!7=FOKkopqtsĘØƘ !$ ,.=>BIEPKQRLUߙۙݙؙљ+7EB@C>UM[W_bedikjϚњӚԚޚߚ"#%'()*./2DCOMNQXtʛƛϛћқԛ:   .%$!0G2F>Z`gvx *&#DA?>FH]^dQPYrozĝƝϝٝӝuy}a̞ΞϞОԞܞޞݞv!,>JRTc_`afgljwrvX/iǐYtdQq~!"!    RSTUVWXYZ[\^_&2A?JRf'138B@IKSg  " $0*.(469=;CGEPLTXVZ\`^dblpjrnhtxvy}{   !%+/)57:><DHFQMUYW[]a_ecmqksoiuwz~|NNNN NNN#N$N(N+N.N/N0N5N@NANDNGNQNZN\NcNhNiNtNuNyNNNNNNNNNNNNNNNNNNNNNNOOOOO O OOOOOO.O1O`O3O5O7O9O;O>O@OBOHOIOKOLOROTOVOXO_OcOjOlOnOqOwOxOyOzO}O~OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPP P PPPPPPPPPP"P'P.P0P2P3P5P@PAPBPEPFPJPLPNPQPRPSPWPYP_P`PbPcPfPgPjPmPpPqP;PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQ Q Q QPQQQQQQQQ#Q'Q(Q,Q-Q/Q1Q3Q4Q5Q8Q9QBQJQOQSQUQWQXQ_QdQfQ~QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRR"R(R1R2R5RSBSLSKSYS[SaScSeSlSmSrSyS~SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTT!T'T(T*T/T1T4T5TCTDTGTMTOT^TbTdTfTgTiTkTmTnTtTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUU U U UUU*U+U2U5U6U;UW?WEWFWLWMWRWbWeWgWhWkWmWnWoWpWqWsWtWuWwWyWzW{W|W~WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXX WX X XXXX X&X'X-X2X9X?XIXLXMXOXPXUX_XaXdXgXhXxX|XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYY Y YYYAYY!Y#Y$Y(Y/Y0Y3Y5Y6Y?YCYFYRYSYYY[Y]Y^Y_YaYcYkYmYoYrYuYvYyY{Y|YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZ Z ZZZZZ#Z$Z'Z(Z*Z-Z0ZDZEZGZHZLZPZUZ^ZcZeZgZmZwZzZ{Z~ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[4[[[[![%[-[8[A[K[L[R[V[^[h[n[o[|[}[~[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\ \\\\#\&\)\+\,\.\0\2\5\6\Y\Z\\\b\c\g\h\i\m\p\t\u\z\{\|\}\\\\\\\\\\\\\\\\\\\\\\\\\]]] ]]+]#]$]&]']1]4]9]=]?]B]C]F]H]U]Q]Y]J]_]`]a]b]d]j]m]p]y]z]~]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^ ^^^^^^ ^.^(^2^5^>^K^P^I^Q^V^X^[^\^^^h^j^k^l^m^n^p^^^^^^^^^^^^^^^^^^^^^^^^^^_________!_"_#_$_(_+_,_._0_4_6_;_=_?_@_D_E_G_M_P_T_X_[_`_c_d_g_o_r_t_u_x_z_}_~________________________________________`` ` ```````$`-`3`5`@`G`H`I`L`Q`T`V`W`]`a`g`q`~``````````````````````````````````````````aaa a aaaaaaaaaaa"a*a+a0a1a5a6a7a9aAaEaFaIa^a`alaraxa{a|aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbb b"b#b'b)b+b9b=bBbCbDbFbLbPbQbRbTbVbZb\bdbmbobsbzb}bbbbbbbbbbbbbbbbbbbbbbccc c c ccccc)c*c-c5c6c9cgEgGgHgLgTgUg]gfglgngtgvg{gggggggggggggggggggggggggggggggggghRhhhhh(h'h,h-h/h0h1h3h;h?hDhEhJhLhUhWhXh[hkhnhohphqhrhuhyhzh{h|hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhii i iiiiii1i3i5i8i;iBiEiIiNiWi[icidieifihiiilipiqirizi{iiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjj j$j(j0j2j4j7j;j>j?jEjFjIjJjNjPjQjRjUjVj[jdjgjjjqjsj~jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjkkkkk kkkkkkk$k(k+k,k/k5k6k;k?kFkJkMkRkVkXk]k`kgkkknkpkuk}k~kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkllll l llllll&l'l(l,l.l3l5l6l:l;l?lJlKlMlOlRlTlYl[l\lklmloltlvlxlyl{llllllllllllllllllllllllllllllllmmm mmmmmm&m'm(lgm.m/m1m9mu?u@uCuGuHuNuPuRuWu^u_uauouquyuzu{u|u}u~uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuvvvvvvv v vvvvvvvvvvv#v%v&v)v-v2v3v5v8v9v:vwBwEwFwJwMwNwOwRwVwWw\w^w_w`wbwdwgwjwlwpwrwswtwzw}wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwxxx x xxxx!x"x#x-x.x0x5x7xCxDxGxHxLxNxRx\x^x`xaxcxdxhxjxnxzx~xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyxxxxxyy yyyyyy y%y'y)y-y1y4y5y;y=y?yDyEyFyJyKyOyQyTyXy[y\ygyiykyryyy{y|y~yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzz z z zzzzz!z'z+z-z/z0z4z5z8z9z:zDzEzGzHzLzUzVzYz\z]z_z`zezgzjzmzuzxz~zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz{{{{#{'{){*{+{-{.{/{0{1{4{={?{@{A{G{N{U{`{d{f{i{j{m{o{r{s{w{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{|||||| | | ||||| |%|&|(|,|1|3|4|6|9|:|F|J|U|Q|R|S|Y|Z|[|\|]|^|a|c|g|i|m|n|p|r|y|||}|||||||||||||||||||||||||||||||}}}} }}}}}}}}#}&}*}-}1}<}=}>}@}A}G}H}M}Q}S}W}Y}Z}\}]}e}g}j}p}x}z}{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}~}}}}}}}}}}}~~~~~~~~ ~'~(~,~-~/~3~6~?~D~E~G~N~P~R~X~_~a~b~e~k~n~o~s~x~~~~~~~~~~~~~<;=>?CDGORS[\]acdefmq}~  $&,.04579:<>@D`dfmquȀ̀πҀԀՀ׀؀  $',05:@CEMX]adeoqr{ȇɇʇ·Շևهڇ܇߇ (-.025:@BEFIORWZ[\abcknpsuz{|}ԉՉ։׉؉ "$&+,/57=>@CEGIMNSVWX\]aeguvwyz{~ÊƊȊɊʊъӊԊՊ׊݊ߊ  -07EGIKOQSTWX[]Ycdfhimsuv{~ŌƌɌˌό֌Ռٌ݌ eilnōƍǍȍʍ΍эԍՍ׍ٍ  !"#&'136789=@AKMNOT[\]^abilmopqyz{ÎĎǎώюԎ܎ !#%'(,-.4567:@ACGOQRSTUX]^eƏʏˏ͏ЏҏӏՏ ()/*,-347?CDL[]bfglpty̐ÐĐŐǐȐՐאِؐܐݐߐҐ  %"#')./14679:<=CGHOSWYZ[adgmtyz{‘Ñőӑԑבّڑޑ #$%&(./035689:<>@BCFGJMNOQXY\]`aeghinopuvwxy{|}’ÒŒƒǒȒ˒̒͒ΒВӒՒגْؒܒݒߒ !$%')*3467GHIPQRUWXZ^degijmopqstvz}ēœƓǓɓʓ˓͓̓ӓٓܓޓߓ ./1234;?=CEHJLUY\_achkmnoqrxy~ƕȕɕ˕Еѕҕӕٕڕݕޕߕ"$%&,13789:<=ARTVWXant{|~ʖ]ؖږݖޖߖ !"#(13ACJNOUWXZ[cgjnsvwx{}ėŗǗɗʗ̗͗ΗЗїԗחؗٗݗޗۗ   #&+./0235%>DGJQRSVWYZbcefjl˜ŘȘ̘"&'+123459:;<@AFGHMNTXY[\^_`Ùəәԙٙڙܙޙ  "#$'-.3568GADJKLNQTV]ÚƚȚΚКҚ՚֚ךۚܚ  &+-34579:=HKLUVW[^acefhjklmnsuwxyǛțΛЛכ؛ݛߛ "#&'()*1567=ACDEIJNOPSTVX[]^_cij\khnpruw{ /0234:?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO!QRSTUVWXYZ[\^_PKM]Parser/Encodings/euc-kr.encnu6$EUC-KR}F  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~}?A}A;AAAuA3AAAmA+AAA eA #A A A ]A A AAUAAAAMA AAAEAAAA=A?AA^AAAxA'_AAAVA A` A`!A`!}A!A"A#YA$A$A%A&QA'A'A(A)IA*A*A+A,AA,A-A.{A/9A/A0A1sA21^2^3M^3^4 ^4g^4^5#^5^5^6=^6^6^7W^7^8^8q^8^9-^9^9^:G^:^;^;a^;^<^<{^<^=7^=^=^>Q^>^? ^?k^?^@'^@^@^AA^A^A^B[^B^C^Cu^C^D1^D^D^EK^E^F^Fe  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{| !"#%&'()*+.234567:;=>?ABCDEFGHIJLNOPQRSUVWYZ[]^_`abcdefghijklmnorsuvy{|}~¬ìŬƬǬɬʬˬͬάϬЬѬҬӬԬ֬ج٬ڬ۬ܬݬެ߬ !"#$%&'(*+./0123679:;=>?@ABCFHJKLMNOQRSUVWYZ[\]^_`bdefghijknoqrwxyz~­íŭƭǭɭʭ˭̭ͭέϭҭԭխ֭׭ح٭ڭۭݭޭ߭  !"#$%&'()*+,-./23569;<=>?BDGHIKOQRSUWXYZ[^bcdfgjkmnoqrstuvwz~®îŮƮǮȮɮʮˮήҮӮԮծ֮׮ڮۮݮޮ߮  !"#$%&'()*+./1356789:;>@DEFGJKLMNOQRSTUVWXYZ[^_`abcfghijklmnopqrstuvwxz{|}~¯ïįůƯʯ̯ϯЯѯүӯկ֯ׯدٯگۯݯޯ߯  !"#$%&')*+,-./0123456789:;<=>?@ABCFGIKMOPQRVXZ[\^_`abcdefghijklmnopqrstuvwxyz{~°ðưʰ˰̰ͰΰϰӰհְװٰڰ۰ܰݰް߰  !"&')*+-./01236:;<=>?BCEFGIJKLMNORSVWYZ[]^_abcdefghijklmnopqrstuvwz{}~±ñıűƱDZȱɱʱ˱ͱαϱѱұӱֱױرٱڱ۱ޱ !"#$%&'()*+,-./012356789:;=>?@ABCDEFGHIJKLMNOPQRSTUVWYZ[]^_abcdefgjklmnopqrsvwxyz{}~²òIJŲƲDzʲ˲ͲβϲѲӲԲղֲײڲܲ޲߲  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSWYZ]`abcfhjlmorsuvwyz{|}~³óƳdzɳʳͳϳѳҳӳֳسڳܳ޳߳ !"#$%&'*,-./012356789:;<=>?@ABCDEFGHIJKLMNORSUVWYZ[\]^_bdfghijkmnopqrstuvwxyz{|}~´ôŴƴǴɴʴ˴̴ʹδϴѴҴӴԴִ״شٴڴ۴޴ߴ  !"#&+,-./235679:;<=>?BFGHIJNOQRSUVWXYZ[^bcdefghijklmnopqrstuvwxyz{|}~µõŵƵǵȵɵʵ˵εҵӵԵյֵ׵ٵڵ۵ܵݵ޵ߵ  !"#$&'()*+-./012356789:;<=>?@ABCDEFGIJKLMNOPQRSTUVWXYZ[\]^_`abcefgijklmnopqrstuvwxyz{|}~¶öĶŶƶǶȶɶʶ˶̶Ͷζ϶жѶҶӶնֶ׶ضٶڶ۶ܶ޶߶  !"#$%&'*+-.1234567:<=>?@ABCEFGIJKMNOPQRSVWXYZ[\]^_abcefgijklmnortvwxyz{~·÷ķŷƷȷʷ˷̷ͷηϷзѷҷӷԷշַ׷طٷڷ۷ܷ޷߷  !"#&')*+-./01236:;<=>?ABCEFGHIJKLMNOPRTUVWXYZ[^_abcefghijknprstuvwyz{}~¸ĸƸǸȸɸʸ˸͸θϸѸҸӸոָ׸ظٸڸ۸ܸ޸ !"#$%&'()*+,-./0123456789:;>?ABCEFGHIJKMNPRSTUVWZ[]^_abcdefgjlnopqrsvwyz{}~¹ùĹŹƹǹʹ˹͹ӹԹչֹ׹ڹܹ߹  !"#$%&'()*+,-./01234567:;=>?ACDEFGJLOPQRVWYZ[]^_`abcfjklmnorsuvwyz{|}~ºúźƺǺɺʺ˺̺ͺκϺкѺҺӺԺպֺ׺ںۺܺݺ޺ߺ !"#$%&'(*,-./012379:?@ABCFHJKLNQRSUVWYZ[\]^_`bdefghijkmnopqrstuvwxyz{|}~»ûŻƻǻɻʻ˻̻ͻλϻѻһԻջֻ׻ػٻڻۻܻݻ޻߻  !"#&(*+,./235679:;<=>?BFGHJKNOQRSTUVWXYZ[\^_`abcdefghijklmnopqrstuvwxyz{|}~¼üżƼǼȼɼʼ˼̼μҼӼԼּ׼ټڼۼݼ޼߼  !"#%&'()*+-./0123456789:;<=>?ABCDEFGJKMNOQRSTUVWZ[\]^_`abcefgijklmnopqrstuvwxyz{|}~½ýĽŽƽǽȽɽʽ˽̽ͽνϽнѽҽӽֽ׽ٽڽ۽ݽ޽߽  !"#$%&'()*+,-./0123456789:;<=>?@ABCFGIJKMOPQRSVX\]^_bcefgiklmnorvwxyz~¾þľžƾǾȾɾʾ˾̾;ξϾҾվ־پھ۾ܾݾ޾߾  !"#$%&'()*+,-./0123456789:;<=>?BCEFGIJKLMNORSTVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~¿ÿĿƿǿȿɿʿ˿οϿѿҿӿտֿ׿ؿٿڿۿݿ޿  !"#$%&'()*+,-./0123456789:;=>?@ABCDEFGHIJKLMNOPRSTUVWYZ[]^_abcdefgjklmnopqrstuvwxyz{|}~ !"%()*+.23457:;=>?ABCDEFGJNOPQRSVWYZ[]^_`abcfjklmnoqrsuvwyz{|}~ !"#$%&'*,.0356789:;<=>?@ABCDEFGIJKLMNORSUVWYZ[\]^_abcdfghijknoqrsuvwxyz{~€‚ƒ„…†‡Š‹ŒŽ‘’“”•–—™šœžŸ ¡¢£¦§©ª«®¯°±²³¶¸º»¼½¾¿  !"#&'*+,-./0123456789:;<=>?@ABCDFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgjkmnoqstuvwz{~ÀÁÂÃÅÆÇÉÊËÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ  !"#%&'()*+-./12356789:;>?@ABCDEFGIJKLMNOPQRSTUVWXYZ[\]^_`abcfgijkmnopqrsvwxz{|}~āĂ㥹ĆćĈĉĊċČčĎďĐđĒēĕĖėĘęĚěĝĞğĠġĢģĤĥĦħĨĩĪīĬĭĮįİıIJijĴĵĶķĹĺĻĽľĿ  !"#$%&'*+-./1234567:<>?@ABCFGKOPQRVZ[\_bcefgijklmnorvwxyz{~ŁłŃŅņňʼnŊŋŎŐŒœŔŖřŚśŝŞşšŢţŤťŦŧŨŪūŬŭŮůŰűŲųŶŷźſ  !"#&')*+/1268:<=>?BCEFGIJKLMNORVWXYZ[^_abcdefghijkmnprstuvwz{}~ƁƂƃƄƅƆƇƊƌƎƏƐƑƒƓƖƗƙƚƛƝƞƟƠơƢƣƦƨƪƫƬƭƮƯƲƳƵƶƷƻƼƽƾƿ "#%&')*+,-./24689:;>?ABCEFGHIKNPYZ[]^_abcdefgijlmnopqrsvwyz{ǀǁǂdžNjnjǍǏǒǓǕǙǛǜǝǞǟǢǧǨǩǪǫǮǯDZDzdzǵǶǷǸǹǺǻǾ !"#%&'()*+.02345679:;=>?ABCDEFGJKNOPQRSUVWXYZ[\]^_`abcdefghijklmnorsuvwy{|}~ȂȄȈȉȊȎȏȐȑȒȓȕȖȗȘșȚțȜȞȠȢȣȤȥȦȧȩȪȫȬȭȮȯȰȱȲȳȴȵȶȷȸȹȺȻȾȿ 000 % &0 "%<"<    0000 0 0 0 0 0000"`"d"e""4 2 3!!+&B&@" "#"""a"R ;&&%%%%%%%%%%%!!!!!0"j"k""=""5"+","" """""*")"'"( !"#$%&'()*+-./012356789:;<=>?@ABCDEFGHIJKLMNORSUVWYZ[\]^_bdefghijkmno!!""^".""! 0%%%%&d&`&a&e&g&c"%%%%%%%%%%%&h&&&& !!!!!!&m&i&j&l22!3!"33!!qrsuvwxyz{}~ɀɁɂɃɄɅɆɇɊɋɍɎɏɑɒɓɔɕɖɗɚɜɞɟɠɡɢɣɤɥɦɧɨɩɪɫɬɭɮɯɰɱɲɳɴɵɶɷɸɹɺɻɼɽɾɿ  !"#$%&'()*+,-./0123456789:;=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]  !"#$%&'(*+,-./0123456789:;<=>?@ABCDEF1112131415161718191:1;1<1=1>1?1@1A1B1C1D1E1F1G1H1I1J1K1L1M1N1O1P1Q1R1S1T1U1V1W1X1Y1Z1[1\1]1^1_1`1a1b1c1d1e1f1g1h1i1j1k1l1m1n1o1p1q1r1s1t1u1v1w1x1y1z1{1|1}1~1111111111111111GHIJKNOQRSUVWXYZ[^bcdefgijklmnopqrstuvwxyz{|~ʀʁʂʃʅʆʇʈʉʊʋʌʍʎʏʐʑʒʓʔʕʖʗʙʚʛʜʝʞʟʠʡʢʣʤʥʦʧ!p!q!r!s!t!u!v!w!x!y!`!a!b!c!d!e!f!g!h!iʨʩʪʫʬʭʮʯʰʱʲʳʴʵʶʷʸʹʺʻʾʿ %%% %%%%%,%$%4%<%%%%%%%#%3%+%;%K% %/%(%7%?%%0%%%8%B%%%%%%%% %%%!%"%&%'%)%*%-%.%1%2%5%6%9%:%=%>%@%A%C%D%E%F%G%H%I%J "#$%&'()*+,-./0123456789:;<=>?@BCDEFGJKMNOQRSTUVWZ[\^_`abcefghijkl333!3333333333333333333333333333333333333333333333333333!&3333333333333333333333mnopqrstuvwz{|}~ˀˁ˂˃˄˅ˆˇˈˉˊˋˌˍˎˏːˑ˒˓˔˕˖˗˘˙˚˛˝˞˟ˠˡˢˣˤ˥˦˧˨˩˪˫ˬ˭ˮ˯˰˱˲˳˴˵˶˷˹˺˻˼˽˾˿&2?ARfJ2`2a2b2c2d2e2f2g2h2i2j2k2l2m2n2o2p2q2r2s2t2u2v2w2x2y2z2{$$$$$$$$$$$$$$$$$$$$$$$$$$$`$a$b$c$d$e$f$g$h$i$j$k$l$m$n!S!T![!\!]!^  #$'138@BSgKI2222222222 2 2 2 2 22222222222222$$$$$$$$$$$$$$$$$$$$$$$$$$$t$u$v$w$x$y$z${$|$}$~$$$$ t  %&*+-/1234567:?@ABCFGIJKMNOPQRSVZ[\]^_abcegijklmnoqrstvwxyz{|}~̀́̂̃̄̅̆̇̈̉̊̋̌̍̎̏̐̑̒̓0A0B0C0D0E0F0G0H0I0J0K0L0M0N0O0P0Q0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z0{0|0}0~000000000000000000000̶̷̡̢̧̛̖̗̝̞̟̣̤̥̦̪̮̯̰̱̲̳̹̺̻̔̽̾̿̕̚00000000000000000000000000000000000000000000000000000000000000000000000000000000000000  !"#%&')*+-./012345678:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_ !"#$%&'()*+,-./012345Q6789:;<=>?@ABCDEFGHIJKLMNOabcefghijknprstuvwyz{|}~͇͉͍͎̀́͂̓̈́͆͊͋͌ͅ͏͓͖͙͚͐͑͒͗͛ͣͦͨͪͫͬͭͮͯ͟͢͝͞͠͡ͱͲͳʹ͵Ͷͷ͸͹ͺͻͼͽ;Ϳ "#%&')*+,-./246789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWZ[]^bcdefgjlnopqrsvwyz{}~΀΁΂΃ΆΈΊ΋Ό΍ΎΏΒΓΕΖΗΙΚΛΜΝΞΟ΢ΦΧΨΩΪΫήίΰαβγδεζηθικλμνξο  $,-/0189<@KMTX\pqtwxzĬȬ̬լ׬ !"#%&'()*+.2345679:;<=>?@ABCDEFGHIJKLMNOPQRSVWYZ[]^_`abcfhjkl  ),-458?@ABCFHJKLMNOQRSUVWYZ[\]^_abcdefghijknoqrsuvwxyz{~ЀЂЃЄЅІЇЈЉЊЋЌЍЎЏАБВГД߱  4?BFGHIJKNOQRSUVWXYZ[^`bcdefgijkm@ACDEKLMPT\]_`aĵ̵͵ϵеѵص%,4HdhԶ(),/089;DHLTU`dhpqsu|}nopqrstuvwxyz{}~рстухцчщъыьэюяѐёђѓєѕіїјљњћќѝўџѢѣѥѦѧѩѪѫѬѭѮѯѲѴѶѷѸѹѻѽѾѿϷǷɷ $%(,45789@DQS\]`dlmoqx|øŸ̸иԸݸ߸ <=@DLOQXY\`hi  !"#$%&'()kmtux|ȹɹ̹ιϹйѹҹعٹ۹ݹ޹89<@BHIKMNSTUX\deghipqtxĺȺغٺ*+./12356789:;>@BCDEFGIJKLMNOPQRSTUVWXYZ[]^_`abcefghijklmnopqrstuvwxyz{|}~҂҃҅҆҇҉ҊҋҌ  )+4568;<=>DEGIMOPTXaclĻȻлӻ $%')-0148@ACDEILMP]ҍҎҏҒғҔҖҗҘҙҚқҝҞҟҡҢңҥҦҧҨҩҪҫҭҮүҰҲҳҴҵҶҷҺһҽҾļͼϼмѼռؼܼ $,@HILPXYdhԽսؽܽ DEHLNTUWYZ[`ad "#$&'*+-./1234567:>?@ABCFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghihjpqstu{|}оѾԾ׾ؾ @ADHPQUſ̿ͿпԿܿ߿?ABCEFGHIJKLMNOPQRSTUVWXYZ[]^_abcefghijklnpqrstuvwz{}~ԁԃԄԅԆԇԊԌԎԏԐԑԒԓԕԖԗԘԙԚԛԜԝ4<=HdehltuyĀĔĜĸļ (),089;=DEHIJLMNSTUWXY]^`adhpqstu|}ŀńŇŌōŏőŕŗŘŜŠũŴŵŸŹŻżŽžԞԟԠԡԢԣԤԥԦԧԨԪԫԬԭԮԯ԰ԱԲԳԴԵԶԷԸԹԺԻԼԽԾԿ $%(,-.034579;@ADHPQSTU\]`loqxy|ƀƈƉƋƍƔƕƘƜƤƥƧƩưƱƴƸƹƺ  !"#$%&'()*+,-./0123456789:;>?ABCEFGHIJKNPRSTUVWZ[]^_abc  !$(01357<=@DJLMOQRSTUVWX\`hktux|}~ǃDŽDžLJLjljNJǎǐǑǔǖǗǘǚǠǡǣǤǥǦǬǭǰǴǼǽǿ dfgjlnopqrsvwyz{}~ՀՁՂՃՆՊՋՌՍՎՏՑՒՓՔՕՖ՗՘ՙ՚՛՜՝՞՟ՠաբգդզէըթժիլխծկհձղճմյնշոչպջռսվտ $,-/18<@HILMTpqtxzȀȁȃȅȆȇȋȌȍȔȝȟȡȨȼȽ ,4PQTX`aclpt|ɈɉɌɐɘəɛɝ !"#%&'()*+,./01234567:; )LMPT\]_`ah}ʄʘʼʽ !AHILPXY]dxy˜˸ !"'(),.089;=>?ABCDFGJLNOPRSVWYZ[]^_`abcdefhjklmnorsuvwxyz{|}~րցւքֆևֈ։֊֋֎֏֑֖֛֢֣֤֥֦֧֪֚֒֓֕֗֘֙֜֞֠֩<=>DEHLTUWXY`dfhpų̴̵̸̘̙̜̠̩̫̬̭̼ $(,9\`dlmoqx͈͔͕ͤͥͧͩ͘͜Ͱ  !$(0135ֱֲֳִֵֶַָֺּֽ֭֮֫֯־ֿ XY\_`ahikmtux|΄΅·ΉΐΑΔΘΠΡΣΤΥάέ $,-/018TUX\degipqtxπυόϡϨϰ-458<!"#$%&'*,./0123679:;=>?@ABCEFHJKLMNORSUZ[\]^_bdfghjkmnoqrsuvwxyz{~׀ׂ׃ׅׄ׆ׇ׊׋DEGIPTX`lmpt|}ЁФХШЬдезй 0148:@ACDELMPT\]_ahl|фшѠѡѤѨѰѱѳѵѺѼ ,-04<=?AH\׍׎׏בגדהוזחךלמןנסעףdҀҁ҄҈ҐґҕҜҠҤҬұҸҹҼҿ  !%(),089;<=DE|}ӀӄӌӍӏӐӑӘәӜӠӨөӫӭӴӸӼ@D\`dmoxy|ԀԂԈԉԋԍԔԩ <=@DLMOQXY\`ehikmtux|ՄՅՇՈՉՐե $-89<@EHIKMQTUX\gipqtփօ֌֍֐ְֹֻ֔֝֟֡֨֬ ()+-458ahe9iouvv{U[WQ|P(S\E]bcnddn py[ݎ}EN~NPe]^aiWqTGu+N^Pgph@Q RRjwR`/PHacdhpLt/t{Pʼnܙ(R.`]bOQIS!X^fm8prs{P[SfckNVPXJX`*a'biЛA[}_NPTU[ ]]e*eNh!jKrvw}^NߏNʙUNNEN]NOQwRS@SSTVWuW[]^abeQggikPkklBnpxrstwwzv}  ߈b3dҚEןW \@ʗTzَ͐X\Hcz[_zyzP&R8RSwWbcrk mw7SsWhvg:jopm̙Kfwkx<SW-YNcisxEzz|us5RWGuG{`̒jXQKRKRbhiuPRRaeh9it~{K뉲9љI NYdfjt4yy~_ &O S`%bqlr}}fNQbw܀OOQvQUVhW;WWYYGY[\]]^~_beeggg^hhj_k:l#l}lmst&t*ttuxuxxyAyGyHyz{}}-OHw!$Qe}OvT bhTUQ: Za bbfqV cOczSW!gi`ns"u7#$%} &'rVZ()*+,NC-QgYHg.Ys^tdy_`lbc{[[R/Yt_)`012tY3456789:;<=>?@ABCoDE`FGfHI\?JKLMNOPQZ%g{}RSTUVWXY\r-RL]Pde,ko|C~͉dbɁ؈^gmjrttoO] _ QcueNPQiQhj|||oҏOQ7RTB^anb>ejoy*܈#bjRfkwpy+bBabe#o#qIt}o&#JQRRm pȈ^eko|>suNO6V_\]`s{-΀F4HaOoyR`ddjo^prv\2ouxy}ɓX_g'p't|`~Q!p(rbxʌŒڌNP[^eqvBwJ|'XZA\bjmov;}/~78KRegimAnpt t`uYv$xk,^Qmb.xOP+]m}*_aDhaRҀQQi^z}uOR)STU\e`gNhmlrrttbu|lyψ̑ЖTo~qtWgmt3x,z{ |ditjuxx虬T[^Uo NSMZ)]_Nabc=fifno+pcw,;E;Ubg+l jzNY__g}T+WYZ[f'ghkqdu㐁EL@[_lsvv߄ QQMQRhlww }}bnŅQT T}ffi'nvw‡iOQRY^=aUdxdyfgj!kkr_ratAw8wۀ(g(lrgvwfzFklY"g&SoXY^cf4gsn:s+zׂד(R]aab bdeiYkfkq!su]~Fj'aXPRT;UOelv} } ^RlriTsZ\>]K_L_g*hicneef ginx}!+*2P OcW_bcgonCqvÀ̀ڈ)MjO/Op^gh"v}v~D^aj qiqujd~ACO{OpQ^hl>lNlr{ălt:PRXdjtvVx9eS^_R%wINPQu\[^wff:ghpuuyzݏ' OX!X1[fnkemnzo}su+܉\OPSS\[_g yy/9;g,NvOYI\\\cghpqt+~+"ҜN NOPRVRoT&TWY+Zf[Z[u[^fbvewemnnr6{&|?6PQ@tܖDٜSRT)VtXYTYn_abnfl~qv||}gO[__b])g hx|~ClNPSS*SQYZb^`abIbyegikkkklht5uxxyy|}ဥ>ƒ芹l^۟;V[*_lejkm\opr]sӘ;al7XNMNNNO:Oy@y`y{}}r цLjߊP^܍fߞRJigjPR*\qeclUsu#u{x0Nwdkq^N kgIhnkcoN PPQUFUV[@\\^8^^^`hQjanXr=r@rvye{ԈsaޗX^tUlza}"rrruu%m{XX]^^_`UbceMfffhhrt^{n}n}r͟ YYm^-`ffsglPmo_wxƑ˓+NPQHU[ [bGe~en2q}ttDttvly}~Uz9ux%MSh\QiTlm)n+ ;-gRafk~ ]emqnWY[`'`bff_s)svw{lVreNRkrmz{9}0oSV/XQ[\\]b@cdf-hlmnppqu&uuv{{|+} }9,m4 a7O\lg_m|~[k]d \s[`g~mފ R7ppQxpOSUVWXZ[\\^%ab bKcde6exj9kl4mo1qrsxttv&wayzWz|}}~a)1څꈖ8Bl֗ӛSX~Y[p[moZqt!t]__`BehiojSkm5msvw{M}#@cbđb Se]]']it_hob҉6rNNXPRSGbf~i^OSV6YZ\8\N\M^_`Cef/fBggswy:ń͉fiUzW[_`obi kn\q{҇UXߘO8OOT{Z [aT3UXbXYgZ[`aeVefdhlZopqsR{}2\KlsDs:ntevzi~ Q@Xdtuvp͙Tn&tzzهxZI[[himcstt,x}UL.f_egljsP-ZkjwY]l]s%uOPQX/Y-YY[]bdddfjHqtdzz~G~^p‡ YÐRa~k2mt~%OPQRWX[^aBimngnqtbu(u,s8Ɏ NOQPvQ*SSS[[\$aaer[st@vyPyy}Ն^GꖅR_gef1h/q\z6 NjRkoqSK1NqQCSTWWWZZ[`(a?clm9nrnr0s?tWшE`ƖbXg^OMPIPSqW YZ\ apfn-r2tK}Äf?_[U˛ONsOQQjU/U[z[^|^}^``aa ce8g ggiaiblm'n8os6s7t\u1vR}8Պۊ0BJ>zIɓnX kӀQAYk\9odsגۀbp}hW`iaGkNYTm-pcl㐑QaɁOPQ[aadikuwdcpNNO Y7Y]__[`!r>supuy 3Q茽 p7vNNRSpTVY[__nn}j5mwNOZO~Xen8NXYY`AzOQeSDNRi[UNR:TYY[P[W[\`caHnpqnstux}+(ɊǖO\RVef(p|pr5}Lr[qhkozv\fo[{|*6NNS X4XXYl\^3^_5cfgVjjk o?rFsPtz|x߁烊l#ψݍwQTW([bMgPh=hn=np}~! KNr-{͓OGONQ2TY^bguinjlnrs*u{}5W[Ο_RT Z[dXeunrvzM{|M~>߃{+ʍd_iOCOzPQhQxRMRjXaX|Y`\\U^`b0hkloqNt u0u8uQvr{L{{{~n>I?"+ZkRb*bmYvdz{}vS`\^o8p|cdzvNNNP\PuTHY[^@^^_`c:e?etefvfxgihjkcl@mmnn^ppssu:w[xyz z}|}Gꌞ-Jؒf̓ V\R6RU|X$^_`choym{,ͅDd=LJOQFQRV2__kcdefAffghhioonqgqr*tw:yVyZyz z||}D~pT m;՜e|[X\ SRbsP'[_`akhmt.z.}B}~1k*5~OPWP]^c+jN;OOOPZY݀TjThUYO[]^f]g1gh*lm2nJopsu|L}},}ۊ;p31NRDz|OQQW[\fYj=mZnoq uoz"!u˙N-NFS}jiklAzXafbpuu~RINKSTW0W@_ccdoe/efzggkbl`lo,wx%yIyW}󂝂rvzz7~TwUUXuc/d"fIfKhmikm%nsthtu[uvwwy~ ~/:ю돰2csOSYZ^hNtuyz̏egWoW}ݏ/_aoNOPSU]o]k!kdx{IʐncId>w@z/jdoqttz|~|~ }LR9[dg-}.PSXyaXaYaezًP P!RuU1Z<^_pa4e^f f6fino2sv!z9YքPW[[_icx&}܅!ǑQg{VQY`UPRT\:a}bbdenv `_NSCUY)]dlmszw!QTU_do}M5P\lmuw|=|dyXY^cwrRuwk܌^ftm}˗QRCfmn}.^RRTabbhiiZj5pq&x]yyyz xՃIIbOVqwׇ[_gQSXZ[`ad`~=p%dP]gXbciixjnkvy˂)ύKۚ6 Nu\y]z{Q{~.ĎYtf%i?tCQg.QE_l]w`ST9V4Z6\1pZ퍣_PtNS`n,\dOP$U\^_`ehlmquuvazzI}}n􆩏əRRGRŘ퉪NgoO[glmxtx'ݓ|yz1_NTU>XY`bSbg6iU5@P,SSUDW|bXdfkgoot"t88TQVWf_HakNpXp}Yj+cw=XTd-i[^noiQLSY*` aKklpl{΂ԍƐdodeQNTWa_hvu{R}qXí*9PxYWYb*a]ryWaZF]bddgwlm>r,t6x4wۘR$WBgrHt㌩*QkScLOiU`eWlmrLrz_mopaOPObArG{}MWj^sg UT [^c^_ e=[OHSS STTW^`bbcUlmfux2ށ/ބa ^EffprOR}_jaSgSjotyhhyǘĚCTziSJ_|buvBS9_<_lsubu{FNO\c>myrϘ0NQDRW_blnppPpqstiJaQn_W`agfYJNNNT|XXY}\_'b6bHf fgkmimnVnooop]rt%tZtvy\|~ႦkN_twje`bwZZfmn>t?B_`{T_l^lm*p}y ;ST[j:pkuuyyqAt de+xxzkN8UYP[^{`ckafehSnqet}i%m;ns>AQ^L_`M`a0aLfCfDiln_nobqLtv{|'RWQS/V^_`b`affgjmoppsj~j4ԊRsr[jkTV[]eHefhmmr;uMOPSTT?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   & ! 0` 9Zd}y     "  !"a :[e~zA^{B_=>|T9 CGPXnpbU: DHQYoqcPKM]lFLParser/Encodings/READMEnu6$This directory contains binary encoding maps for some selected encodings. If they are placed in a directory listed in @XML::Parser::Expat::Encoding_Path, then they are automatically loaded by the XML::Parser::Expat::load_encoding function as needed. Otherwise you may load what you need directly by explicitly calling this function. These maps were generated by a perl script that comes with the module XML::Encoding, compile_encoding, from XML formatted encoding maps that are distributed with that module. These XML encoding maps were generated in turn with a different script, domap, from mapping information contained on the Unicode version 2.0 CD-ROM. This CD-ROM comes with the Unicode Standard reference manual and can be ordered from the Unicode Consortium at http://www.unicode.org. The identical information is available on the internet at ftp://ftp.unicode.org/Public/MAPPINGS. See the encoding.h header in the Expat sub-directory for a description of the structure of these files. Clark Cooper December 12, 1998 ================================================================ Contributed maps This distribution contains four contributed encodings from MURATA Makoto that are variations on the encoding commonly called Shift_JIS: x-sjis-cp932.enc x-sjis-jdk117.enc x-sjis-jisx0221.enc x-sjis-unicode.enc (This is the same encoding as the shift_jis.enc that was distributed with this module in version 2.17) Please read his message (Japanese_Encodings.msg) about why these are here and why I've removed the shift_jis.enc encoding. We also have two contributed encodings that are variations of the EUC-JP encoding from Yoshida Masato : x-euc-jp-jisx0221.enc x-euc-jp-unicode.enc The comments that MURATA Makoto made in his message apply to these encodings too. KangChan Lee supplied the euc-kr encoding. Clark Cooper December 26, 1998 PKM]!?00Parser/Encodings/iso-8859-7.encnu6$ISO-8859-7  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   z PKM]:\'Parser/Encodings/Japanese_Encodings.msgnu6$Mapping files for Japanese encodings 1998 12/25 Fuji Xerox Information Systems MURATA Makoto 1. Overview This version of XML::Parser and XML::Encoding does not come with map files for the charset "Shift_JIS" and the charset "euc-jp". Unfortunately, each of these charsets has more than one mapping. None of these mappings are considered as authoritative. Therefore, we have come to believe that it is dangerous to provide map files for these charsets. Rather, we introduce several private charsets and map files for these private charsets. If IANA, Unicode Consoritum, and JIS eventually reach a consensus, we will be able to provide map files for "Shift_JIS" and "euc-jp". 2. Different mappings from existing charsets to Unicode 1) Different mappings in JIS X0221 and Unicode The mapping between JIS X0208:1990 and Unicode 1.1 and the mapping between JIS X0212:1990 and Unicode 1.1 are published from Unicode consortium. They are available at ftp://ftp.unicode.org/Public/MAPPINGS/EASTASIA/JIS/JIS0208.TXT and ftp://ftp.unicode.org/Public/MAPPINGS/EASTASIA/JIS/JIS0212.TXT, respectively.) These mapping files have a note as below: # The kanji mappings are a normative part of ISO/IEC 10646. The # non-kanji mappings are provisional, pending definition of # official mappings by Japanese standards bodies. Unfortunately, the non-kanji mappings in the Japanese standard for ISO 10646/1, namely JIS X 0221:1995, is different from the Unicode Consortium mapping since 0x213D of JIS X 0208 is mapped to U+2014 (em dash) rather than U+2015 (horizontal bar). Furthermore, JIS X 0221 clearly says that the mapping is informational and non-normative. As a result, some companies (e.g., Microsoft and Apple) have introduced slightly different mappings. Therefore, neither the Unicode consortium mapping nor the JIS X 0221 mapping are considered as authoritative. 2) Shift-JIS This charset is especially problematic, since its definition has been unclear since its inception. The current registration of the charset "Shift_JIS" is as below: >Name: Shift_JIS (preferred MIME name) >MIBenum: 17 >Source: A Microsoft code that extends csHalfWidthKatakana to include > kanji by adding a second byte when the value of the first > byte is in the ranges 81-9F or E0-EF. >Alias: MS_Kanji >Alias: csShiftJIS First, this does not reference to the mapping "Shift-JIS to Unicode" published by the Unicode consortium (available at ftp://ftp.unicode.org/Public/MAPPINGS/EASTASIA/JIS/SHIFTJIS.TXT). Second, "kanji" in this registration can be interepreted in different ways. Does this "kanji" reference to JIS X0208:1978, JIS X0208:1983, or JIS X0208:1990(== JIS X0208:1997)? These three standards are *incompatible* with each other. Moreover, we can even argue that "kanji" refers to JIS X0212 or ideographic characters in other countries. Third, each company has extended Shift JIS. For example, Microsoft introduced OEM extensions (NEC extensionsand IBM extensions). Forth, Shift JIS uses JIS X0201, which is almost upper-compatible with US-ASCII but is not quite. 5C and 7E of JIS X 0201 are different from backslash and tilde, respectively. However, many programming languages (e.g., Java) ignore this difference and assumes that 5C and 7E of Shift JIS are backslash and tilde. 3. Proposed charsets and mappings As a tentative solution, we introduce two private charsets for EUC-JP and four priviate charsets for Shift JIS. 1) EUC-JP We have two charsets, namely "x-eucjp-unicode" and "x-eucjp-jisx0221". Their difference is only one code point. The mapping for the former is based on the Unicode Consortium mapping, while the latter is based on the JIS X0221 mapping. 2) Shift JIS We have four charsets, namely x-sjis-unicode, x-sjis-jisx0221, x-sjis-jdk117, and x-sjis-cp932. The mapping for the charset x-sjis-unicode is the one published by the Unicode consortium. The mapping for x-sjis-jisx0221 is almost equivalent to x-sjis-unicode, but 0x213D of JIS X 0208 is mapped to U+2014 (em dash) rather than U+2015. The charset x-sjis-jdk117 is again almost equivalent to x-sjis-unicode, but 0x5C and 0x7E of JIS X0201 are mapped to backslash and tilde. The charset x-sjis-cp932 is used by Microsoft Windows, and its mapping is published from the Unicode Consortium (available at: ftp://ftp.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP932.txt). The coded character set for this charset includes NEC-extensions and IBM-extensions. 0x5C and 0x7E of JIS X0201 are mapped to backslash and tilde; 0x213D is mapped to U+2015; and 0x2140, 0x2141, 0x2142, and 0x215E of JIS X 0208 are mapped to compatibility characters. Makoto Fuji Xerox Information Systems Tel: +81-44-812-7230 Fax: +81-44-812-7231 E-mail: murata@apsdc.ksp.fujixerox.co.jp PKM]̿00 Parser/Encodings/iso-8859-15.encnu6$ISO-8859-15  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ `a}~RSxPKM]Rx0GG$Parser/Encodings/x-sjis-jisx0221.encnu6$x-sjis-jisx0221(%  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|} >abcdefghijklmnopqrstuvwxyz{|}~\@@OL@@^@c@ @@@W@@@@ K@ @ @ @ ?@ @ @v@3@@@j@'@@@^@@@@R@@@@F@@e > abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'000 000@>?00000N0000  \0 \ & %     00;=[]00 0 0 0 0 0000 ""`"f"g""4&B&@ 2 3! &&%%%%%%%%%%% ;0!!!!0"" """""*")"'"(!!""" "#"""a"R"j"k""=""5"+",!+ 0&o&m&j !%!"#$%&'()*+,-./0123456789:ABCDEFGHIJKLMNOPQRSTUVWXYZ0A0B0C0D0E0F0G0H0I0J0K0L0M0N0O0P0Q0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z0{0|0}0~00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 !"#$%&'()*+,-./012345Q6789:;<=>?@ABCDEFGHIJKLMNO%%% %%%%%,%$%4%<%%%%%%%#%3%+%;%K% %/%(%7%?%%0%%%8%BNUZ?Tac(Y"uzP`cn%efhW'ebq[YІ{}b}b|[^c fhHǗgONO OMOPIVY7YZ\ `aapfipuOupy}}ÄcUzS;NNW߀xNXn8z2(/QASpTTVY_m-bpT S[p–So\zNxn&VUk;YSmftܕVBNKO SU[0_qf fhl8lm)t[vzN4[`muvʙ`iSQWX0YD[^`(cclopqqYqs?~vх`[XielZu%QY.Ye__bej*k'ksV,\l{Q\KahvraNYOSx`in)zON SNOUO=OOsRSV YZ[[yfggkLlpksyyz<{ۃwӇfV)NO\brYu;傽řNOVXJX^_`*``babbe9AffhmwppuLv}uQRYT[]ahimxˈWrmlWgΒRVT^bdhkSlWo"ooEtuvw z{|!}6f̌Qeә(N8T+\]svLw<\ TXOOSqUVhWYG[ [\^ ^~_cg:eeghhj_^0kll}uyH[cz}_w̏Z/__`hjtZxwN^NO|OPPQIQlRRRSSTTUWQWY}[T[][]]]^x^^^_`RaLbbce;ffCfgmh!hil_m*min/nu2vxlz?|}}}^}T*RLaʑuqx?M؝;R[RSTXboj_QKR;TJVz@w`sDo pu_`ښrۏkdNVWdXZZ`haffh9hmu}:nBNOPSU]o]]gltsxPWP^c+PPQgTX^Y[_ibMch=ksnp}rxx&yme}0܈ RdW(gPjQWB*X:iT]WxO\RJTd>f(ggz{V}"/h\{9SQR7[bddg-kvcLvfRN PS\q`dech_qsu#{~ۑxefkNNO:OR:SSUVXYYY[P\M^^+_`ce/[\eeegkbk{lsEyIy|}}+󉖊^ifnjܖ̘koNOtuxy: 3ꄔlP_X+z[NSWY1Z[`nou[{Prg\aJ~Q\chfeqny>}ʐnǐPR\:gSp|r5Lȓ+[_1`N;S[bKg1krsz.kRQSTj[cj9}VSTh[\1]Oabm2yy}B~MҁFrt/1KlƑNOOQESA_bglAn sc~&͒SY[my]~.|X~qQSO\f%wzQ_eiokmnodv}]uQRb@ffn^}rfRSYs^_`UdPQRS SGSTUFU1VYhYZ<[\\\\^^^_pbbbccwff f-fvg~hjj5lmn nXq d_xRbcdBb-z{}v INQHSCS`[\\]b&bGdhh4lmEmgo\qNq}ez{}~Jz9n΍xwRMUo8q6Qhy~U|VLXQ\cffiZruuyyVy|} }D4;a PRuSSP UXYOr=[\dS``c\cc?cdef]iioqNuvz|}}aIXlōpmPXaӅ5 OPtRGSs`ocIg_n,O\^e}SRQvc[X[k\ d gQ\NYY*lpQU>XY`bSg5iU@Ě(OSX[\^/_` aKb4flnހ΁Ԉ.ۛNSY'{,Lnp'SSUD[bXbblot"8o8QSSOFTYj1]zꏿhڌ7rHj=N9SXVWfbcekNmn[pwz{}=Ɔˊ[VX_>efjku7P$wW0_`efzl`uznE{u\z{Qyz6Zw@N-N[_bft6x4ZFuO^bceWgovrL̀)MP WZhisqdrXjyw)O/ReSZbglv}{|6fo r~Q{xr{{Hj^auQu`QkbnvzOpb{OVzXY䖼O4R$SJSS^d,egl>lNrHrsuT~A,錩{đqic=fiujvxЅCS*SQT&Y^_|`bIbybekluvxy}w^j |8P\>_gkt5w ;gzS9u_f_<_ub{Feg llpx2~+ނ *JҘlNONPRVWJY^=__b?fgghQ}!~2T ,SPS\Xdg4rgwfzFRlkX^LYTg,QvdixTWYf'gkTi^UggRh]NOSbg+lO~mNabno+Tsg*E]{\[ƇnJzY|lw RY"q!r_wۗ'ai ZZQT T}fvߏYr]nQMh}}bdxj!Y[_ksv}Q2g(vgbR\$b;|~UO`} SN_QYr:6_%wS_y}3Vg󅮔Sa alvR8U/OQQ*RS[^}`acg gngms6s7u1yPՊJćYNOYN?P^|Y[^ccdfiJim nqu(zIɉ! e} a~bk2lmtmge}o#,TBojp2RZA^_gi|imjorbr{~KQmy2P-Tqkjā`gNNkhin~xU_ NNN*N1N6NzYUYPYNYZYXYbY`YgYlYiYxYYO^OYYYYYYYYZ%ZZZZ ZZ@ZlZIZ5Z6ZbZjZZZZZZZZZZZZZ[ [ [[2Z[*[6[>[C[E[@[Q[U[Z[[[e[i[p[s[u[xe[z[[[[[[[[[[[[[[[[[[\\\\ \\ \"\(\8\9\A\F\N\S\P\O[q\l\nNb\v\y\\\Y\\\\\\\\\\\\\]\] ]]]\]]]]]"]]]]L]R]N]K]l]s]v]]]]]]]]]]]]]]]]]]]]^ ^^^^^6^7^D^C^@^N^W^T^_^b^d^G^u^v^z^^^^^^^^^^^^^^^^^^^^^^^__ _]_\_ ___)_-_8_A_H_L_N_/_Q_V_W_Y_a_m_s_w____________________`_`!`````)``1```+`&``:`Z`A`j`w`_`J`F`M`c`C`d`B`l`k`Y`````````````````_````aMaa``a``aa!``a aaGa>a(a'aJa?acMdcOcccccvcccccckcicccccccccdd4ddd&d6edd(ddgdodvdNe*ddddddddddddddd ddbdde,ddddedeeee$e#e+e4e5e7e6e8uKeHeVeUeMeXe^e]erexeeeeeeeeeeeeeeeeegrf fegsf5f6f4ffOfDfIfAf^f]fdfgfhf_fbfpffffffffffffffffff?fffffgggg&g'8g.g?g6gAg8g7gFg^g`gYgcgdggpgg|gjgggggggggggggggggggggjhhFh)h@hMh2hNhh+hYhchwhhhhhhhhjhhthhhihh~ihihi"i&hi hhhhi6iihhi%hhhi(i*ii#i!hiyiwi\ixikiTi~ini9iti=iYi0iai^i]iijiiiiiiii[iiiiij.iiiiiiijjik iiijijijij jjj#jjDj jrj6jxjGjbjYjfjHj8j"jjjjjjjjjjjjjjjjjjjjkjkk1kk8k7vk9kGkCkIkPkYkTk[k_kakxkykkkkkkkkkkkkkkkkkkkkkkkkklllll$l#l^lUlbljllllll~lhlslllllllllllllllllmMm6m+m=m8mm5m3mm mcmmdmZmymYmmommnn mmmmmmmmmmmmmmmmmn-nnn.nnrn_n>n#nkn+nvnMnnCn:nNn$nnn8nnnnnnnnnnnnnnnnoAopLnnno?no1no2no>onoozoxooooo[oomoo|oXoooofooooooooooooooop p opppoppotpppp0p>p2pQpcppppppppppppq pqqqeqUqqfqbqLqVqlqqqqqqqqqqqqqqqqqqqqr rrr(r-r,r0r2r;rsNsOsWsjshspsxsus{szsssssssstttot%st2t:tUt?t_tYtAt\titptctjtvt~ttttttsttttttttttuuuu uu uuuu&u,uz7zCzWzIzazbzizpzyz}zzzzzzzzzzzzzzzzzzzzzzzzzz{{{ {{3{{{{5{({6{P{z{{M{ {L{E{u{e{t{g{p{q{l{n{{{{{{{{{{]{{{{{{{{{||{{|`|||{{|| {|#|'|*||7|+|=|L|C|T|O|@|P|X|_|d|V|e|l|u|||||||||||||||||||||;|||||}}}}} }E}K}.}2}?}5}F}s}V}N}r}h}n}O}c}}}[}}}}}}}}}}}~=}}}}}}}}}}}}}~~ ~#~!~~1~~ ~ ~"~F~f~;~5~9~C~7~2~:~g~]~V~^~Y~Z~y~j~i~|~{~}~}~~~~~~~~~~~~8:ELMNPQUTX_`higxq܀ !(?;JFRXZ_bhsrpvy}Qۀـ݀Āڀց )#/KF>SQqneft_Ɂ́сف؁ȁځ߁ )+83@YX]Z_dbhjk.qwx~߂҂ރ܃ ك5421@9PE/+#|su΃؄  " 8m*(ALONIV[Zk_lot}:A?HLNPUblxz|bȌڌ  N͍gmqsύڍ֍̍ۍˍߍ B504JGILPHYd`*cUvr|ƎŎȎˎێ  &3;9EB>LIFNW\bcdڏ!  '659OPQRI>VX^hovr}bHۑ20JVXceisrɑˑБ֑ߑۑ,^WEIdH?KPZϒD."#:5;\`|nV֓דؓÓݓГȓ6+5!:ARD[`b^j)puw}Z|~oÕ͕̕Օԕ֕ܕ!(./BLOKw\^]_frlΖ˖ɖ͉Mܗ Ֆ$*09=>DFHBI\`dfhRҗkqy|z×Ɨȗ˗ܗOzߗ 8$!7=FOKkopqtsĘØƘ !$ ,.=>BIEPKQRLUߙۙݙؙљ+7EB@C>UM[W_bedikjϚњӚԚޚߚ"#%'()*./2DCOMNQXtʛƛϛћқԛ:   .%$!0G2F>Z`gvx *&#DA?>FH]^dQPYrozĝƝϝٝӝuy}a̞ΞϞОԞܞޞݞv!,>JRTc_`afgljwrvX/iǐYtdQqPKM]_00!Parser/Encodings/windows-1252.encnu6$windows-1252  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   & ! 0` 9R}     "  !"a :S~xPKM]\^00!Parser/Encodings/windows-1251.encnu6$windows-1251  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ S  & ! 0 9   R     "  !"Y :Z\[_^VQ!TXUW !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPKM] d800Parser/Encodings/iso-8859-3.encnu6$ISO-8859-3  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~&$0^4{'%1_5|  l\  !m]PKM]#Y00Parser/Encodings/ibm866.encnu6$ibm866  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?%%%%%$%a%b%V%U%c%Q%W%]%\%[%%%4%,%%%<%^%_%Z%T%i%f%`%P%l%g%h%d%e%Y%X%R%S%k%j%% %%%%%@ABCDEFGHIJKLMNOQTW^""!%PKM]0q00Parser/Encodings/iso-8859-9.encnu6$ISO-8859-9  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~0^1_PKM]Te00Parser/Encodings/koi8-r.encnu6$koi8-r  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~%%% %%%%%$%,%4%<%%%%%%%%# %"""H"d"e#!%P%Q%RQ%S%T%U%V%W%X%Y%Z%[%\%]%^%_%`%a%b%c%d%e%f%g%h%i%j%k%lN01F45D3E89:;<=>?O@ABC62LK7HMIGJ.&$%/ !"#,+(-)'*PKM]#GG#Parser/Encodings/x-sjis-unicode.encnu6$x-sjis-unicode(%  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|} >abcdefghijklmnopqrstuvwxyz{|}~\@@OL@@^@c@ @@@W@@@@ K@ @ @ @ ?@ @ @v@3@@@j@'@@@^@@@@R@@@@F@@e > abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'000 000@>?00000N0000  \0 \ & %     00;=[]00 0 0 0 0 0000 ""`"f"g""4&B&@ 2 3! &&%%%%%%%%%%% ;0!!!!0"" """""*")"'"(!!""" "#"""a"R"j"k""=""5"+",!+ 0&o&m&j !%!"#$%&'()*+,-./0123456789:ABCDEFGHIJKLMNOPQRSTUVWXYZ0A0B0C0D0E0F0G0H0I0J0K0L0M0N0O0P0Q0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z0{0|0}0~00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 !"#$%&'()*+,-./012345Q6789:;<=>?@ABCDEFGHIJKLMNO%%% %%%%%,%$%4%<%%%%%%%#%3%+%;%K% %/%(%7%?%%0%%%8%BNUZ?Tac(Y"uzP`cn%efhW'ebq[YІ{}b}b|[^c fhHǗgONO OMOPIVY7YZ\ `aapfipuOupy}}ÄcUzS;NNW߀xNXn8z2(/QASpTTVY_m-bpT S[p–So\zNxn&VUk;YSmftܕVBNKO SU[0_qf fhl8lm)t[vzN4[`muvʙ`iSQWX0YD[^`(cclopqqYqs?~vх`[XielZu%QY.Ye__bej*k'ksV,\l{Q\KahvraNYOSx`in)zON SNOUO=OOsRSV YZ[[yfggkLlpksyyz<{ۃwӇfV)NO\brYu;傽řNOVXJX^_`*``babbe9AffhmwppuLv}uQRYT[]ahimxˈWrmlWgΒRVT^bdhkSlWo"ooEtuvw z{|!}6f̌Qeә(N8T+\]svLw<\ TXOOSqUVhWYG[ [\^ ^~_cg:eeghhj_^0kll}uyH[cz}_w̏Z/__`hjtZxwN^NO|OPPQIQlRRRSSTTUWQWY}[T[][]]]^x^^^_`RaLbbce;ffCfgmh!hil_m*min/nu2vxlz?|}}}^}T*RLaʑuqx?M؝;R[RSTXboj_QKR;TJVz@w`sDo pu_`ښrۏkdNVWdXZZ`haffh9hmu}:nBNOPSU]o]]gltsxPWP^c+PPQgTX^Y[_ibMch=ksnp}rxx&yme}0܈ RdW(gPjQWB*X:iT]WxO\RJTd>f(ggz{V}"/h\{9SQR7[bddg-kvcLvfRN PS\q`dech_qsu#{~ۑxefkNNO:OR:SSUVXYYY[P\M^^+_`ce/[\eeegkbk{lsEyIy|}}+󉖊^ifnjܖ̘koNOtuxy: 3ꄔlP_X+z[NSWY1Z[`nou[{Prg\aJ~Q\chfeqny>}ʐnǐPR\:gSp|r5Lȓ+[_1`N;S[bKg1krsz.kRQSTj[cj9}VSTh[\1]Oabm2yy}B~MҁFrt/1KlƑNOOQESA_bglAn sc~&͒SY[my]~.|X~qQSO\f%wzQ_eiokmnodv}]uQRb@ffn^}rfRSYs^_`UdPQRS SGSTUFU1VYhYZ<[\\\\^^^_pbbbccwff f-fvg~hjj5lmn nXq d_xRbcdBb-z{}v INQHSCS`[\\]b&bGdhh4lmEmgo\qNq}ez{}~Jz9n΍xwRMUo8q6Qhy~U|VLXQ\cffiZruuyyVy|} }D4;a PRuSSP UXYOr=[\dS``c\cc?cdef]iioqNuvz|}}aIXlōpmPXaӅ5 OPtRGSs`ocIg_n,O\^e}SRQvc[X[k\ d gQ\NYY*lpQU>XY`bSg5iU@Ě(OSX[\^/_` aKb4flnހ΁Ԉ.ۛNSY'{,Lnp'SSUD[bXbblot"8o8QSSOFTYj1]zꏿhڌ7rHj=N9SXVWfbcekNmn[pwz{}=Ɔˊ[VX_>efjku7P$wW0_`efzl`uznE{u\z{Qyz6Zw@N-N[_bft6x4ZFuO^bceWgovrL̀)MP WZhisqdrXjyw)O/ReSZbglv}{|6fo r~Q{xr{{Hj^auQu`QkbnvzOpb{OVzXY䖼O4R$SJSS^d,egl>lNrHrsuT~A,錩{đqic=fiujvxЅCS*SQT&Y^_|`bIbybekluvxy}w^j |8P\>_gkt5w ;gzS9u_f_<_ub{Feg llpx2~+ނ *JҘlNONPRVWJY^=__b?fgghQ}!~2T ,SPS\Xdg4rgwfzFRlkX^LYTg,QvdixTWYf'gkTi^UggRh]NOSbg+lO~mNabno+Tsg*E]{\[ƇnJzY|lw RY"q!r_wۗ'ai ZZQT T}fvߏYr]nQMh}}bdxj!Y[_ksv}Q2g(vgbR\$b;|~UO`} SN_QYr:6_%wS_y}3Vg󅮔Sa alvR8U/OQQ*RS[^}`acg gngms6s7u1yPՊJćYNOYN?P^|Y[^ccdfiJim nqu(zIɉ! e} a~bk2lmtmge}o#,TBojp2RZA^_gi|imjorbr{~KQmy2P-Tqkjā`gNNkhin~xU_ NNN*N1N6NzYUYPYNYZYXYbY`YgYlYiYxYYO^OYYYYYYYYZ%ZZZZ ZZ@ZlZIZ5Z6ZbZjZZZZZZZZZZZZZ[ [ [[2Z[*[6[>[C[E[@[Q[U[Z[[[e[i[p[s[u[xe[z[[[[[[[[[[[[[[[[[[\\\\ \\ \"\(\8\9\A\F\N\S\P\O[q\l\nNb\v\y\\\Y\\\\\\\\\\\\\]\] ]]]\]]]]]"]]]]L]R]N]K]l]s]v]]]]]]]]]]]]]]]]]]]]^ ^^^^^6^7^D^C^@^N^W^T^_^b^d^G^u^v^z^^^^^^^^^^^^^^^^^^^^^^^__ _]_\_ ___)_-_8_A_H_L_N_/_Q_V_W_Y_a_m_s_w____________________`_`!`````)``1```+`&``:`Z`A`j`w`_`J`F`M`c`C`d`B`l`k`Y`````````````````_````aMaa``a``aa!``a aaGa>a(a'aJa?acMdcOcccccvcccccckcicccccccccdd4ddd&d6edd(ddgdodvdNe*ddddddddddddddd ddbdde,ddddedeeee$e#e+e4e5e7e6e8uKeHeVeUeMeXe^e]erexeeeeeeeeeeeeeeeeegrf fegsf5f6f4ffOfDfIfAf^f]fdfgfhf_fbfpffffffffffffffffff?fffffgggg&g'8g.g?g6gAg8g7gFg^g`gYgcgdggpgg|gjgggggggggggggggggggggjhhFh)h@hMh2hNhh+hYhchwhhhhhhhhjhhthhhihh~ihihi"i&hi hhhhi6iihhi%hhhi(i*ii#i!hiyiwi\ixikiTi~ini9iti=iYi0iai^i]iijiiiiiiii[iiiiij.iiiiiiijjik iiijijijij jjj#jjDj jrj6jxjGjbjYjfjHj8j"jjjjjjjjjjjjjjjjjjjjkjkk1kk8k7vk9kGkCkIkPkYkTk[k_kakxkykkkkkkkkkkkkkkkkkkkkkkkkklllll$l#l^lUlbljllllll~lhlslllllllllllllllllmMm6m+m=m8mm5m3mm mcmmdmZmymYmmommnn mmmmmmmmmmmmmmmmmn-nnn.nnrn_n>n#nkn+nvnMnnCn:nNn$nnn8nnnnnnnnnnnnnnnnoAopLnnno?no1no2no>onoozoxooooo[oomoo|oXoooofooooooooooooooop p opppoppotpppp0p>p2pQpcppppppppppppq pqqqeqUqqfqbqLqVqlqqqqqqqqqqqqqqqqqqqqr rrr(r-r,r0r2r;rsNsOsWsjshspsxsus{szsssssssstttot%st2t:tUt?t_tYtAt\titptctjtvt~ttttttsttttttttttuuuu uu uuuu&u,uz7zCzWzIzazbzizpzyz}zzzzzzzzzzzzzzzzzzzzzzzzzz{{{ {{3{{{{5{({6{P{z{{M{ {L{E{u{e{t{g{p{q{l{n{{{{{{{{{{]{{{{{{{{{||{{|`|||{{|| {|#|'|*||7|+|=|L|C|T|O|@|P|X|_|d|V|e|l|u|||||||||||||||||||||;|||||}}}}} }E}K}.}2}?}5}F}s}V}N}r}h}n}O}c}}}[}}}}}}}}}}}~=}}}}}}}}}}}}}~~ ~#~!~~1~~ ~ ~"~F~f~;~5~9~C~7~2~:~g~]~V~^~Y~Z~y~j~i~|~{~}~}~~~~~~~~~~~~8:ELMNPQUTX_`higxq܀ !(?;JFRXZ_bhsrpvy}Qۀـ݀Āڀց )#/KF>SQqneft_Ɂ́сف؁ȁځ߁ )+83@YX]Z_dbhjk.qwx~߂҂ރ܃ ك5421@9PE/+#|su΃؄  " 8m*(ALONIV[Zk_lot}:A?HLNPUblxz|bȌڌ  N͍gmqsύڍ֍̍ۍˍߍ B504JGILPHYd`*cUvr|ƎŎȎˎێ  &3;9EB>LIFNW\bcdڏ!  '659OPQRI>VX^hovr}bHۑ20JVXceisrɑˑБ֑ߑۑ,^WEIdH?KPZϒD."#:5;\`|nV֓דؓÓݓГȓ6+5!:ARD[`b^j)puw}Z|~oÕ͕̕Օԕ֕ܕ!(./BLOKw\^]_frlΖ˖ɖ͉Mܗ Ֆ$*09=>DFHBI\`dfhRҗkqy|z×Ɨȗ˗ܗOzߗ 8$!7=FOKkopqtsĘØƘ !$ ,.=>BIEPKQRLUߙۙݙؙљ+7EB@C>UM[W_bedikjϚњӚԚޚߚ"#%'()*./2DCOMNQXtʛƛϛћқԛ:   .%$!0G2F>Z`gvx *&#DA?>FH]^dQPYrozĝƝϝٝӝuy}a̞ΞϞОԞܞޞݞv!,>JRTc_`afgljwrvX/iǐYtdQqPKM]Im 00!Parser/Encodings/windows-1255.encnu6$windows-1255  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   & ! 0 9     "  !" :   PKM]TOO!Parser/Encodings/x-sjis-cp932.encnu6$x-sjis-cp932.  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~abcdefghijklmnopqrstuvwxyz{|}~\g@@O^@@@]?@^t@@@L@ @@@@@@ @ w@ 4@ @ @ k@(@@@_@@@@S@@@@G@@@~@;@@@r@e/@@Q@@@ \~ abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-000 000@>?00000N0000  <^"%\ & %     00;=[]00 0 0 0 0 0000 "`"f"g""4&B&@ 2 3! &&%%%%%%%%%%% ;0!!!!0"" """""*")"'"(!!""" "#"""a"R"j"k""=""5"+",!+ 0&o&m&j !%!"#$%&'()*+,-./0123456789:ABCDEFGHIJKLMNOPQRSTUVWXYZ0A0B0C0D0E0F0G0H0I0J0K0L0M0N0O0P0Q0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z0{0|0}0~00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 !"#$%&'()*+,-./012345Q6789:;<=>?@ABCDEFGHIJKLMNO%%% %%%%%,%$%4%<%%%%%%%#%3%+%;%K% %/%(%7%?%%0%%%8%B$`$a$b$c$d$e$f$g$h$i$j$k$l$m$n$o$p$q$r$s!`!a!b!c!d!e!f!g!h!i3I33"3M33'3363Q3W3 3&3#3+3J3;33333333{00!3!!222222122293~3}3|"R"a"+"."""" """5")"*NUZ?Tac(Y"uzP`cn%efhW'ebq[YІ{}b}b|[^c fhHǗgONO OMOPIVY7YZ\ `aapfipuOupy}}ÄcUzS;NNW߀xNXn8z2(/QASpTTVY_m-bpT S[p–So\zNxn&VUk;YSmftܕVBNKO SU[0_qf fhl8lm)t[vzN4[`muvʙ`iSQWX0YD[^`(cclopqqYqs?~vх`[XielZu%QY.Ye__bej*k'ksV,\l{Q\KahvraNYOSx`in)zON SNOUO=OOsRSV YZ[[yfggkLlpksyyz<{ۃwӇfV)NO\brYu;傽řNOVXJX^_`*``babbe9AffhmwppuLv}uQRYT[]ahimxˈWrmlWgΒRVT^bdhkSlWo"ooEtuvw z{|!}6f̌Qeә(N8T+\]svLw<\ TXOOSqUVhWYG[ [\^ ^~_cg:eeghhj_^0kll}uyH[cz}_w̏Z/__`hjtZxwN^NO|OPPQIQlRRRSSTTUWQWY}[T[][]]]^x^^^_`RaLbbce;ffCfgmh!hil_m*min/nu2vxlz?|}}}^}T*RLaʑuqx?M؝;R[RSTXboj_QKR;TJVz@w`sDo pu_`ښrۏkdNVWdXZZ`haffh9hmu}:nBNOPSU]o]]gltsxPWP^c+PPQgTX^Y[_ibMch=ksnp}rxx&yme}0܈ RdW(gPjQWB*X:iT]WxO\RJTd>f(ggz{V}"/h\{9SQR7[bddg-kvcLvfRN PS\q`dech_qsu#{~ۑxefkNNO:OR:SSUVXYYY[P\M^^+_`ce/[\eeegkbk{lsEyIy|}}+󉖊^ifnjܖ̘koNOtuxy: 3ꄔlP_X+z[NSWY1Z[`nou[{Prg\aJ~Q\chfeqny>}ʐnǐPR\:gSp|r5Lȓ+[_1`N;S[bKg1krsz.kRQSTj[cj9}VSTh[\1]Oabm2yy}B~MҁFrt/1KlƑNOOQESA_bglAn sc~&͒SY[my]~.|X~qQSO\f%wzQ_eiokmnodv}]uQRb@ffn^}rfRSYs^_`UdPQRS SGSTUFU1VYhYZ<[\\\\^^^_pbbbccwff f-fvg~hjj5lmn nXq d_xRbcdBb-z{}v INQHSCS`[\\]b&bGdhh4lmEmgo\qNq}ez{}~Jz9n΍xwRMUo8q6Qhy~U|VLXQ\cffiZruuyyVy|} }D4;a PRuSSP UXYOr=[\dS``c\cc?cdef]iioqNuvz|}}aIXlōpmPXaӅ5 OPtRGSs`ocIg_n,O\^e}SRQvc[X[k\ d gQ\NYY*lpQU>XY`bSg5iU@Ě(OSX[\^/_` aKb4flnހ΁Ԉ.ۛNSY'{,Lnp'SSUD[bXbblot"8o8QSSOFTYj1]zꏿhڌ7rHj=N9SXVWfbcekNmn[pwz{}=Ɔˊ[VX_>efjku7P$wW0_`efzl`uznE{u\z{Qyz6Zw@N-N[_bft6x4ZFuO^bceWgovrL̀)MP WZhisqdrXjyw)O/ReSZbglv}{|6fo r~Q{xr{{Hj^auQu`QkbnvzOpb{OVzXY䖼O4R$SJSS^d,egl>lNrHrsuT~A,錩{đqic=fiujvxЅCS*SQT&Y^_|`bIbybekluvxy}w^j |8P\>_gkt5w ;gzS9u_f_<_ub{Feg llpx2~+ނ *JҘlNONPRVWJY^=__b?fgghQ}!~2T ,SPS\Xdg4rgwfzFRlkX^LYTg,QvdixTWYf'gkTi^UggRh]NOSbg+lO~mNabno+Tsg*E]{\[ƇnJzY|lw RY"q!r_wۗ'ai ZZQT T}fvߏYr]nQMh}}bdxj!Y[_ksv}Q2g(vgbR\$b;|~UO`} SN_QYr:6_%wS_y}3Vg󅮔Sa alvR8U/OQQ*RS[^}`acg gngms6s7u1yPՊJćYNOYN?P^|Y[^ccdfiJim nqu(zIɉ! e} a~bk2lmtmge}o#,TBojp2RZA^_gi|imjorbr{~KQmy2P-Tqkjā`gNNkhin~xU_ NNN*N1N6NzYUYPYNYZYXYbY`YgYlYiYxYYO^OYYYYYYYYZ%ZZZZ ZZ@ZlZIZ5Z6ZbZjZZZZZZZZZZZZZ[ [ [[2Z[*[6[>[C[E[@[Q[U[Z[[[e[i[p[s[u[xe[z[[[[[[[[[[[[[[[[[[\\\\ \\ \"\(\8\9\A\F\N\S\P\O[q\l\nNb\v\y\\\Y\\\\\\\\\\\\\]\] ]]]\]]]]]"]]]]L]R]N]K]l]s]v]]]]]]]]]]]]]]]]]]]]^ ^^^^^6^7^D^C^@^N^W^T^_^b^d^G^u^v^z^^^^^^^^^^^^^^^^^^^^^^^__ _]_\_ ___)_-_8_A_H_L_N_/_Q_V_W_Y_a_m_s_w____________________`_`!`````)``1```+`&``:`Z`A`j`w`_`J`F`M`c`C`d`B`l`k`Y`````````````````_````aMaa``a``aa!``a aaGa>a(a'aJa?acMdcOcccccvcccccckcicccccccccdd4ddd&d6edd(ddgdodvdNe*ddddddddddddddd ddbdde,ddddedeeee$e#e+e4e5e7e6e8uKeHeVeUeMeXe^e]erexeeeeeeeeeeeeeeeeegrf fegsf5f6f4ffOfDfIfAf^f]fdfgfhf_fbfpffffffffffffffffff?fffffgggg&g'8g.g?g6gAg8g7gFg^g`gYgcgdggpgg|gjgggggggggggggggggggggjhhFh)h@hMh2hNhh+hYhchwhhhhhhhhjhhthhhihh~ihihi"i&hi hhhhi6iihhi%hhhi(i*ii#i!hiyiwi\ixikiTi~ini9iti=iYi0iai^i]iijiiiiiiii[iiiiij.iiiiiiijjik iiijijijij jjj#jjDj jrj6jxjGjbjYjfjHj8j"jjjjjjjjjjjjjjjjjjjjkjkk1kk8k7vk9kGkCkIkPkYkTk[k_kakxkykkkkkkkkkkkkkkkkkkkkkkkkklllll$l#l^lUlbljllllll~lhlslllllllllllllllllmMm6m+m=m8mm5m3mm mcmmdmZmymYmmommnn mmmmmmmmmmmmmmmmmn-nnn.nnrn_n>n#nkn+nvnMnnCn:nNn$nnn8nnnnnnnnnnnnnnnnoAopLnnno?no1no2no>onoozoxooooo[oomoo|oXoooofooooooooooooooop p opppoppotpppp0p>p2pQpcppppppppppppq pqqqeqUqqfqbqLqVqlqqqqqqqqqqqqqqqqqqqqr rrr(r-r,r0r2r;rsNsOsWsjshspsxsus{szsssssssstttot%st2t:tUt?t_tYtAt\titptctjtvt~ttttttsttttttttttuuuu uu uuuu&u,uz7zCzWzIzazbzizpzyz}zzzzzzzzzzzzzzzzzzzzzzzzzz{{{ {{3{{{{5{({6{P{z{{M{ {L{E{u{e{t{g{p{q{l{n{{{{{{{{{{]{{{{{{{{{||{{|`|||{{|| {|#|'|*||7|+|=|L|C|T|O|@|P|X|_|d|V|e|l|u|||||||||||||||||||||;|||||}}}}} }E}K}.}2}?}5}F}s}V}N}r}h}n}O}c}}}[}}}}}}}}}}}~=}}}}}}}}}}}}}~~ ~#~!~~1~~ ~ ~"~F~f~;~5~9~C~7~2~:~g~]~V~^~Y~Z~y~j~i~|~{~}~}~~~~~~~~~~~~8:ELMNPQUTX_`higxq܀ !(?;JFRXZ_bhsrpvy}Qۀـ݀Āڀց )#/KF>SQqneft_Ɂ́сف؁ȁځ߁ )+83@YX]Z_dbhjk.qwx~߂҂ރ܃ ك5421@9PE/+#|su΃؄  " 8m*(ALONIV[Zk_lot}:A?HLNPUblxz|bȌڌ  N͍gmqsύڍ֍̍ۍˍߍ B504JGILPHYd`*cUvr|ƎŎȎˎێ  &3;9EB>LIFNW\bcdڏ!  '659OPQRI>VX^hovr}bHۑ20JVXceisrɑˑБ֑ߑۑ,^WEIdH?KPZϒD."#:5;\`|nV֓דؓÓݓГȓ6+5!:ARD[`b^j)puw}Z|~oÕ͕̕Օԕ֕ܕ!(./BLOKw\^]_frlΖ˖ɖ͉Mܗ Ֆ$*09=>DFHBI\`dfhRҗkqy|z×Ɨȗ˗ܗOzߗ 8$!7=FOKkopqtsĘØƘ !$ ,.=>BIEPKQRLUߙۙݙؙљ+7EB@C>UM[W_bedikjϚњӚԚޚߚ"#%'()*./2DCOMNQXtʛƛϛћқԛ:   .%$!0G2F>Z`gvx *&#DA?>FH]^dQPYrozĝƝϝٝӝuy}a̞ΞϞОԞܞޞݞv!,>JRTc_`afgljwrvX/iǐYtdQq~HOpf1hȒf_EN(NNOOO9OVOOOOOP@P"OPPFPpPBPPPQJQdQQQRRRRRSSS$SrSSSTTTTUWYWeWWWXXY YSY[Y]YcYY[V[u/[[\\\\]']S]B]m]]]_!_4_g__`]````a `aa7a0abbcd`ddeNfff;f f.ff$fefWfYfsfffffg)gfghRghhDhihiij0jkjFjsj~jjkl?l\llolmmmommmmmmn9n\n'n?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~g?gL?^^PCKSVL8Q +^K^^^e^^!^^^;^^^U^^^o^^ +^ ^ ^ E^ ^ ^ _^ ^ ^ y^ ^ 5^ ^ ^O3^^>^^^X^^^r^^.^^^H^^^b^^^|^^8^^^R^^^l^^(^^^B^^^\^~Ca=}0VWWA^^^T^^^n^^ *^ ^ ^!D^!^"^"^^"^#^#x^#^$4^$^$^%N^%^& ^&h^&^'$^'^'^(>^(^(^)X^)^*^*r^*^+.^+^+^,H^,^-^-b^-^.^.|^.^/8^/^/^0R^0^1^1l^1^2(^2^2^3B^3C3  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOabcdefghijklmnopqrstuvwxyz{|}~PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~000 000@>?00000N0000  \0 \ & %     00;=[]00 0 0 0 0 0000 ""`"f"g""4&B&@ 2 3! &&%%%%%%%%%%% ;0!!!!0"" """""*")"'"(!!""" "#"""a"R"j"k""=""5"+",!+ 0&o&m&j !%!"#$%&'()*+,-./0123456789:ABCDEFGHIJKLMNOPQRSTUVWXYZ0A0B0C0D0E0F0G0H0I0J0K0L0M0N0O0P0Q0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z0{0|0}0~00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 !"#$%&'()*+,-./012345Q6789:;<=>?@ABCDEFGHIJKLMNO%%% %%%%%,%$%4%<%%%%%%%#%3%+%;%K% %/%(%7%?%%0%%%8%BNUZ?Tac(Y"uzP`cn%efhW'ebq[YІ{}b}b|[^c fhHǗgONO OMOPIVY7YZ\ `aapfipuOupy}}ÄcUzS;NNW߀xNXn8z2(/QASpTTVY_m-bpT S[p–So\zNxn&VUk;YSmftܕVBNKO SU[0_qf fhl8lm)t[vzN4[`muvʙ`iSQWX0YD[^`(cclopqqYqs?~vх`[XielZu%QY.Ye__bej*k'ksV,\l{Q\KahvraNYOSx`in)zON SNOUO=OOsRSV YZ[[yfggkLlpksyyz<{ۃwӇfV)NO\brYu;傽řNOVXJX^_`*``babbe9AffhmwppuLv}uQRYT[]ahimxˈWrmlWgΒRVT^bdhkSlWo"ooEtuvw z{|!}6f̌Qeә(N8T+\]svLw<\ TXOOSqUVhWYG[ [\^ ^~_cg:eeghhj_^0kll}uyH[cz}_w̏Z/__`hjtZxwN^NO|OPPQIQlRRRSSTTUWQWY}[T[][]]]^x^^^_`RaLbbce;ffCfgmh!hil_m*min/nu2vxlz?|}}}^}T*RLaʑuqx?M؝;R[RSTXboj_QKR;TJVz@w`sDo pu_`ښrۏkdNVWdXZZ`haffh9hmu}:nBNOPSU]o]]gltsxPWP^c+PPQgTX^Y[_ibMch=ksnp}rxx&yme}0܈ RdW(gPjQWB*X:iT]WxO\RJTd>f(ggz{V}"/h\{9SQR7[bddg-kvcLvfRN PS\q`dech_qsu#{~ۑxefkNNO:OR:SSUVXYYY[P\M^^+_`ce/[\eeegkbk{lsEyIy|}}+󉖊^ifnjܖ̘koNOtuxy: 3ꄔlP_X+z[NSWY1Z[`nou[{Prg\aJ~Q\chfeqny>}ʐnǐPR\:gSp|r5Lȓ+[_1`N;S[bKg1krsz.kRQSTj[cj9}VSTh[\1]Oabm2yy}B~MҁFrt/1KlƑNOOQESA_bglAn sc~&͒SY[my]~.|X~qQSO\f%wzQ_eiokmnodv}]uQRb@ffn^}rfRSYs^_`UdPQRS SGSTUFU1VYhYZ<[\\\\^^^_pbbbccwff f-fvg~hjj5lmn nXq d_xRbcdBb-z{}v INQHSCS`[\\]b&bGdhh4lmEmgo\qNq}ez{}~Jz9n΍xwRMUo8q6Qhy~U|VLXQ\cffiZruuyyVy|} }D4;a PRuSSP UXYOr=[\dS``c\cc?cdef]iioqNuvz|}}aIXlōpmPXaӅ5 OPtRGSs`ocIg_n,O\^e}SRQvc[X[k\ d gQ\NYY*lpQU>XY`bSg5iU@Ě(OSX[\^/_` aKb4flnހ΁Ԉ.ۛNSY'{,Lnp'SSUD[bXbblot"8o8QSSOFTYj1]zꏿhڌ7rHj=N9SXVWfbcekNmn[pwz{}=Ɔˊ[VX_>efjku7P$wW0_`efzl`uznE{u\z{QĐyz6Zw@N-N[_bft6x4ZFuO^bceWgovrL̀)MP WZhisqdrXjyw)O/ReSZbglv}{|6fo r~Q{xr{{Hj^auQu`QkbnvzOpb{OVzXY䖼O4R$SJSS^d,egl>lNrHrsuT~A,錩{đqic=fiujvxЅCS*SQT&Y^_|`bIbybekluvxy}w^j |8P\>_gkt5w ;gzS9u_f_<_ub{Feg llpx2~+ނ *JҘlNONPRVWJY^=__b?fgghQ}!~2T ,SPS\Xdg4rgwfzFRlkX^LYTg,QvdixTWYf'gkTi^UggRh]NOSbg+lO~mNabno+Tsg*E]{\[ƇnJzY|lw RY"q!r_wۗ'ai ZZQT T}fvߏYr]nQMh}}bdxj!Y[_ksv}Q2g(vgbR\$b;|~UO`} SN_QYr:6_%wS_y}3Vg󅮔Sa alvR8U/OQQ*RS[^}`acg gngms6s7u1yPՊJćYNOYN?P^|Y[^ccdfiJim nqu(zIɉ! e} a~bk2lmtmge}o#,TBojp2RZA^_gi|imjorbr{~KQmy2P-Tqkjā`gNNkhin~xU_ NNN*N1N6NzYUYPYNYZYXYbY`YgYlYiYxYYO^OYYYYYYYYZ%ZZZZ ZZ@ZlZIZ5Z6ZbZjZZZZZZZZZZZZZ[ [ [[2Z[*[6[>[C[E[@[Q[U[Z[[[e[i[p[s[u[xe[z[[[[[[[[[[[[[[[[[[\\\\ \\ \"\(\8\9\A\F\N\S\P\O[q\l\nNb\v\y\\\Y\\\\\\\\\\\\\]\] ]]]\]]]]]"]]]]L]R]N]K]l]s]v]]]]]]]]]]]]]]]]]]]]^ ^^^^^6^7^D^C^@^N^W^T^_^b^d^G^u^v^z^^^^^^^^^^^^^^^^^^^^^^^__ _]_\_ ___)_-_8_A_H_L_N_/_Q_V_W_Y_a_m_s_w____________________`_`!`````)``1```+`&``:`Z`A`j`w`_`J`F`M`c`C`d`B`l`k`Y`````````````````_````aMaa``a``aa!``a aaGa>a(a'aJa?acMdcOcccccvcccccckcicccccccccdd4ddd&d6edd(ddgdodvdNe*ddddddddddddddd ddbdde,ddddedeeee$e#e+e4e5e7e6e8uKeHeVeUeMeXe^e]erexeeeeeeeeeeeeeeeeegrf fegsf5f6f4ffOfDfIfAf^f]fdfgfhf_fbfpffffffffffffffffff?fffffgggg&g'8g.g?g6gAg8g7gFg^g`gYgcgdggpgg|gjgggggggggggggggggggggjhhFh)h@hMh2hNhh+hYhchwhhhhhhhhjhhthhhihh~ihihi"i&hi hhhhi6iihhi%hhhi(i*ii#i!hiyiwi\ixikiTi~ini9iti=iYi0iai^i]iijiiiiiiii[iiiiij.iiiiiiijjik iiijijijij jjj#jjDj jrj6jxjGjbjYjfjHj8j"jjjjjjjjjjjjjjjjjjjjkjkk1kk8k7vk9kGkCkIkPkYkTk[k_kakxkykkkkkkkkkkkkkkkkkkkkkkkkklllll$l#l^lUlbljllllll~lhlslllllllllllllllllmMm6m+m=m8mm5m3mm mcmmdmZmymYmmommnn mmmmmmmmmmmmmmmmmn-nnn.nnrn_n>n#nkn+nvnMnnCn:nNn$nnn8nnnnnnnnnnnnnnnnoAopLnnno?no1no2no>onoozoxooooo[oomoo|oXoooofooooooooooooooop p opppoppotpppp0p>p2pQpcppppppppppppq pqqqeqUqqfqbqLqVqlqqqqqqqqqqqqqqqqqqqqr rrr(r-r,r0r2r;rsNsOsWsjshspsxsus{szsssssssstttot%st2t:tUt?t_tYtAt\titptctjtvt~ttttttsttttttttttuuuu uu uuuu&u,uz7zCzWzIzazbzizpzyz}zzzzzzzzzzzzzzzzzzzzzzzzzz{{{ {{3{{{{5{({6{P{z{{M{ {L{E{u{e{t{g{p{q{l{n{{{{{{{{{{]{{{{{{{{{||{{|`|||{{|| {|#|'|*||7|+|=|L|C|T|O|@|P|X|_|d|V|e|l|u|||||||||||||||||||||;|||||}}}}} }E}K}.}2}?}5}F}s}V}N}r}h}n}O}c}}}[}}}}}}}}}}}~=}}}}}}}}}}}}}~~ ~#~!~~1~~ ~ ~"~F~f~;~5~9~C~7~2~:~g~]~V~^~Y~Z~y~j~i~|~{~}~}~~~~~~~~~~~~8:ELMNPQUTX_`higxq܀ !(?;JFRXZ_bhsrpvy}Qۀـ݀Āڀց )#/KF>SQqneft_Ɂ́сف؁ȁځ߁ )+83@YX]Z_dbhjk.qwx~߂҂ރ܃ ك5421@9PE/+#|su΃؄  " 8m*(ALONIV[Zk_lot}:A?HLNPUblxz|bȌڌ  N͍gmqsύڍ֍̍ۍˍߍ B504JGILPHYd`*cUvr|ƎŎȎˎێ  &3;9EB>LIFNW\bcdڏ!  '659OPQRI>VX^hovr}bHۑ20JVXceisrɑˑБ֑ߑۑ,^WEIdH?KPZϒD."#:5;\`|nV֓דؓÓݓГȓ6+5!:ARD[`b^j)puw}Z|~oÕ͕̕Օԕ֕ܕ!(./BLOKw\^]_frlΖ˖ɖ͉Mܗ Ֆ$*09=>DFHBI\`dfhRҗkqy|z×Ɨȗ˗ܗOzߗ 8$!7=FOKkopqtsĘØƘ !$ ,.=>BIEPKQRLUߙۙݙؙљ+7EB@C>UM[W_bedikjϚњӚԚޚߚ"#%'()*./2DCOMNQXtʛƛϛћқԛ:   .%$!0G2F>Z`gvx *&#DA?>FH]^dQPYrozĝƝϝٝӝuy}a̞ΞϞОԞܞޞݞv!,>JRTc_`afgljwrvX/iǐYtdQq~!"!    RSTUVWXYZ[\^_&2A?JRf'138B@IKSg  " $0*.(469=;CGEPLTXVZ\`^dblpjrnhtxvy}{   !%+/)57:><DHFQMUYW[]a_ecmqksoiuwz~|NNNN NNN#N$N(N+N.N/N0N5N@NANDNGNQNZN\NcNhNiNtNuNyNNNNNNNNNNNNNNNNNNNNNNOOOOO O OOOOOO.O1O`O3O5O7O9O;O>O@OBOHOIOKOLOROTOVOXO_OcOjOlOnOqOwOxOyOzO}O~OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPP P PPPPPPPPPP"P'P.P0P2P3P5P@PAPBPEPFPJPLPNPQPRPSPWPYP_P`PbPcPfPgPjPmPpPqP;PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQ Q Q QPQQQQQQQQ#Q'Q(Q,Q-Q/Q1Q3Q4Q5Q8Q9QBQJQOQSQUQWQXQ_QdQfQ~QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRR"R(R1R2R5RSBSLSKSYS[SaScSeSlSmSrSyS~SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTT!T'T(T*T/T1T4T5TCTDTGTMTOT^TbTdTfTgTiTkTmTnTtTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUU U U UUU*U+U2U5U6U;UW?WEWFWLWMWRWbWeWgWhWkWmWnWoWpWqWsWtWuWwWyWzW{W|W~WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXX WX X XXXX X&X'X-X2X9X?XIXLXMXOXPXUX_XaXdXgXhXxX|XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYY Y YYYAYY!Y#Y$Y(Y/Y0Y3Y5Y6Y?YCYFYRYSYYY[Y]Y^Y_YaYcYkYmYoYrYuYvYyY{Y|YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZ Z ZZZZZ#Z$Z'Z(Z*Z-Z0ZDZEZGZHZLZPZUZ^ZcZeZgZmZwZzZ{Z~ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[4[[[[![%[-[8[A[K[L[R[V[^[h[n[o[|[}[~[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\ \\\\#\&\)\+\,\.\0\2\5\6\Y\Z\\\b\c\g\h\i\m\p\t\u\z\{\|\}\\\\\\\\\\\\\\\\\\\\\\\\\]]] ]]+]#]$]&]']1]4]9]=]?]B]C]F]H]U]Q]Y]J]_]`]a]b]d]j]m]p]y]z]~]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^ ^^^^^^ ^.^(^2^5^>^K^P^I^Q^V^X^[^\^^^h^j^k^l^m^n^p^^^^^^^^^^^^^^^^^^^^^^^^^^_________!_"_#_$_(_+_,_._0_4_6_;_=_?_@_D_E_G_M_P_T_X_[_`_c_d_g_o_r_t_u_x_z_}_~________________________________________`` ` ```````$`-`3`5`@`G`H`I`L`Q`T`V`W`]`a`g`q`~``````````````````````````````````````````aaa a aaaaaaaaaaa"a*a+a0a1a5a6a7a9aAaEaFaIa^a`alaraxa{a|aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbb b"b#b'b)b+b9b=bBbCbDbFbLbPbQbRbTbVbZb\bdbmbobsbzb}bbbbbbbbbbbbbbbbbbbbbbccc c c ccccc)c*c-c5c6c9cgEgGgHgLgTgUg]gfglgngtgvg{gggggggggggggggggggggggggggggggggghRhhhhh(h'h,h-h/h0h1h3h;h?hDhEhJhLhUhWhXh[hkhnhohphqhrhuhyhzh{h|hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhii i iiiiii1i3i5i8i;iBiEiIiNiWi[icidieifihiiilipiqirizi{iiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjj j$j(j0j2j4j7j;j>j?jEjFjIjJjNjPjQjRjUjVj[jdjgjjjqjsj~jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjkkkkk kkkkkkk$k(k+k,k/k5k6k;k?kFkJkMkRkVkXk]k`kgkkknkpkuk}k~kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkllll l llllll&l'l(l,l.l3l5l6l:l;l?lJlKlMlOlRlTlYl[l\lklmloltlvlxlyl{llllllllllllllllllllllllllllllllmmm mmmmmm&m'm(lgm.m/m1m9mu?u@uCuGuHuNuPuRuWu^u_uauouquyuzu{u|u}u~uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuvvvvvvv v vvvvvvvvvvv#v%v&v)v-v2v3v5v8v9v:vwBwEwFwJwMwNwOwRwVwWw\w^w_w`wbwdwgwjwlwpwrwswtwzw}wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwxxx x xxxx!x"x#x-x.x0x5x7xCxDxGxHxLxNxRx\x^x`xaxcxdxhxjxnxzx~xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyxxxxxyy yyyyyy y%y'y)y-y1y4y5y;y=y?yDyEyFyJyKyOyQyTyXy[y\ygyiykyryyy{y|y~yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzz z z zzzzz!z'z+z-z/z0z4z5z8z9z:zDzEzGzHzLzUzVzYz\z]z_z`zezgzjzmzuzxz~zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz{{{{#{'{){*{+{-{.{/{0{1{4{={?{@{A{G{N{U{`{d{f{i{j{m{o{r{s{w{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{|||||| | | ||||| |%|&|(|,|1|3|4|6|9|:|F|J|U|Q|R|S|Y|Z|[|\|]|^|a|c|g|i|m|n|p|r|y|||}|||||||||||||||||||||||||||||||}}}} }}}}}}}}#}&}*}-}1}<}=}>}@}A}G}H}M}Q}S}W}Y}Z}\}]}e}g}j}p}x}z}{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}~}}}}}}}}}}}~~~~~~~~ ~'~(~,~-~/~3~6~?~D~E~G~N~P~R~X~_~a~b~e~k~n~o~s~x~~~~~~~~~~~~~<;=>?CDGORS[\]acdefmq}~  $&,.04579:<>@D`dfmquȀ̀πҀԀՀ׀؀  $',05:@CEMX]adeoqr{ȇɇʇ·Շևهڇ܇߇ (-.025:@BEFIORWZ[\abcknpsuz{|}ԉՉ։׉؉ "$&+,/57=>@CEGIMNSVWX\]aeguvwyz{~ÊƊȊɊʊъӊԊՊ׊݊ߊ  -07EGIKOQSTWX[]Ycdfhimsuv{~ŌƌɌˌό֌Ռٌ݌ eilnōƍǍȍʍ΍эԍՍ׍ٍ  !"#&'136789=@AKMNOT[\]^abilmopqyz{ÎĎǎώюԎ܎ !#%'(,-.4567:@ACGOQRSTUX]^eƏʏˏ͏ЏҏӏՏ ()/*,-347?CDL[]bfglpty̐ÐĐŐǐȐՐאِؐܐݐߐҐ  %"#')./14679:<=CGHOSWYZ[adgmtyz{‘Ñőӑԑבّڑޑ #$%&(./035689:<>@BCFGJMNOQXY\]`aeghinopuvwxy{|}’ÒŒƒǒȒ˒̒͒ΒВӒՒגْؒܒݒߒ !$%')*3467GHIPQRUWXZ^degijmopqstvz}ēœƓǓɓʓ˓͓̓ӓٓܓޓߓ ./1234;?=CEHJLUY\_achkmnoqrxy~ƕȕɕ˕Еѕҕӕٕڕݕޕߕ"$%&,13789:<=ARTVWXant{|~ʖ]ؖږݖޖߖ !"#(13ACJNOUWXZ[cgjnsvwx{}ėŗǗɗʗ̗͗ΗЗїԗחؗٗݗޗۗ   #&+./0235%>DGJQRSVWYZbcefjl˜ŘȘ̘"&'+123459:;<@AFGHMNTXY[\^_`Ùəәԙٙڙܙޙ  "#$'-.3568GADJKLNQTV]ÚƚȚΚКҚ՚֚ךۚܚ  &+-34579:=HKLUVW[^acefhjklmnsuwxyǛțΛЛכ؛ݛߛ "#&'()*1567=ACDEIJNOPSTVX[]^_cij\khnpruw{ /0234:?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Y@Y@@@W@@@@S@@@@O@ @ @ @ K@ @ @ @G@@@@C@@@@?@@@|@;@@@x@7@@@t@1@@@n@ -@ @!@"j@#)@#@$@%f@&%@&@'@(b@)!@)@*@+^@,@,@-@.Z@/@/@0@1V@2@2@3@4R@5@5@6@7N@8 @8@9@:J@; @;@<@=F@>@>@?@@B@A?  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX0 00 "0 & %PdRTUVW\ 1 34O 56[]78009:00;<0 0 =>00 ?@0 0 AB00CDYZ[\]^    00 5 2 ;0%%%%%&&%%%%%%2! >?IJMNKL_`a ""f"g"`""R"abcdef"<")"*"" ""33"+"."5"4&@&B&A& !!!!!!!!"%"#<0 !! ijk333333333QYQ[Q^Q]QaQcUt|%%%%%%%%%%%%%%%%<%4%,%$%%%%%% %%%%m%n%p%o%P%^%j%a%%%%%q%r%s!`!a!b!c!d!e!f!g!h!i0!0"0#0$0%0&0'0(0)SD!"#$%&'()*+,-./0123456789:ABCDEFGHIJKLMNOPQRSTUVWXYZ11111 1 1 1 1 1111111111111111111 1!1"1#1$1%1&1'1(1)NNYNNNCN]NNNQ?QeQkQRRRSSAS\SN N NN N+N8QNENHN_N^NNQ@RRSCSSWXYY'Ys[P[Q[S[\\"\8\q]]]]]]^r^_ _bMNNN N-N0N9NK\9NNNNNNNNNNNNNNNQCQAQgQmQnQlQQRRRRRRSS9SHSGSES^SSSSXY)Y+Y*Y-[T\\$\:\o]^{^___bb6bKbNe/eeeeefgg(k kbkykkkll4pkr*r6r;rGrYr[rsNNNNNN;NMNONNNNNNNNNNNNQEQDQQQQQQR RRSSSSNSJSISaS`SoSnSSSSSSSSSSSSSSSSSSSSVVYY.Y1YtYv[U[\<]]]^^^s^|____b bSbTbRbQeeg.g,g*g+g-kcklll8lAl@l>rssttuuu(u)u0u1u2u3uv}vvvwwwy:yztzNNNRNSNiNNNNNO OO OO OOONNNNNNOO QIQGQFQHQhQqQQRRRRRRSS!S SpSqT TT T TTT TTT TTTTTVVVW3W0W(W-W,W/W)YYY7Y8YYxYY}YyYY[W[X[[[[[\\y]^^v^t____bb b bbcb[bXe6eeeeffg g=g4g1g5k!kdk{ll]lWlYl_l`lPlUlal[lMlNppr_r]v~z|s|6 3 nr~k@Lc!N2NOMOOOGOWO^O4O[OUO0OPOQO=O:O8OCOTOT&TNT'TFTCT3THTBTT)TJT9T;T8T.T5T6T TWPWOW;XY>YYYYYYYYYYYY[][\[Z[[[[[\,\@\A\?\>\\\\]^ ^^^^___d_b_w_y________bbbbbbbvbbmbb|b~bybsbbobbnbbbbe9e;e8efg_gNgOgPgQg\gVg^gIgFg`gSgWkeklBl^llllllljlzllpllhlll}llrl~ltllvllllpvp|p}pxrbrar`rrsu,u+u7u8vvwyyyzv|UoҊ7FUdpʏƏŏ]ᐑIƑ̖2.1*,N&NVNsNNNNNOoOOOsOOlOOOOOpOuOOiO{OO~OOOzQTQRQUQiQwQvQxQQR;R8R7R:R0R.R6RARRSRSTSSSQSfSwSxSySSSTsTuTTxTTT{TwTTTT|TTqTvTTTbThTT}TVWWwWjWiWaWfWdW|YYIYGYHYDYTYYYYYYYYYYYYYYYY[_[d[c[[[[[[\\H\E\F\\\\\\\^^^^^^^x^^^^^^_&_'_)____|_____```/`5``*``!`'`)`+`bbb?b>b@bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbe>eeefff fffffff fg g gmgggqggsgwggggogpggg~gguggg|gjgrk#kfkgkllllllllllllllllllllllllllllllllllpppppr,r-r8rHrgrirrrrrsssssu=uuuvvvvwwy>y@yAyyzzzyz|T NqRhˏΏԏѐǑѕw@?;DBR^NNNOOOOOOOOOOOOOOOOOOOOOOQWQQQRNRCRJRMRLRKRGRRRRS SWS{SSTTTTTTTTTTTTTTTTTTTTTTVWWWWWWWWYUYQYOYNYPYYYYYZYYYYZY[i[[[[[\\N\O\M\K\\]^^%^^}^^^__-_e_______``` `%``(`M`p`h`b`F`C`l`k`j`dbAbcc bbcbbcbbbbbbcce?eEeeef%f-f f'f/ff(f1f$fgggggggggggggggggggggggggkjkkkkkllm m2m*mAm%m m1mmm;m=m>m6mlm9m'm8m)m.m5mm+pppppppppr0rrrortrrrsssssssuu-uOuLuNuKuuuuuvxvvvvvvvwvvw w vvwwxxx x yFyIyHyGyyyyyzzzz|}}}}} }}}8 6րڀÀĀ̀ۀ΀ހ݁"ۂ ҂ׂ܂Ԃтނӂ߂Py{zMkԊts͎̏ʐΐÑKJ͕PKLMbi˗ۘߙNXNP P P#OP&P%OP)PPPc/cUcBcFcOcIc:cPc=c*c+c(cMcLeHeIeeefBfIfOfCfRfLfEfAfgggh!h8hHhFhSh9hBhTh)hhhLhQh=ghPh@hSfUFUjUfUDU^UaUCUJU1UVUOUUU/UdU8U.U\U,UcU3UAUWWW W WXX XWWWXX5WWY YbZ6ZAZIZfZjZ@ZwUUUUUU~UUUW X/X*X4X$X0X1X!XX XXY`ZwZZZZZ[s[q[[[[\ \ \1]L]P]4]G]^E^=^@^C^~^^^^_<_m___`````aa#`a```ah`a`a aabbIccccccccccccccccvcccdRcce^efebeceeefnfpftfvfoffzf~fwffgghhhhhihhhhhhhhhhi iihhinhk>k:k=kkkkl.l/l,n/n8nTn!n2ngnJn n%n#nn[nXn$nVnnn-n&non4nMn:n,nCnn>nnnnNncnDnrnin_qqq&q0q!q6qnqrLrrs6s%s4s)t:t*t3t"t%t5t6t4t/tt&t(u%u&ukujuuuuuuuv{v|vvvvwOwx]xlxoz zz zzzzzzz{I{V{F{P{R{T{M{K{O{Q||}^}P}h}U}+}n}r}a}f}b}p}sUՀ RUTKQN9F>LSt ń W ̃ʄ8܄ԃ߆[߆نԆۆІވWˆ;`U^a4a'a aa7b!b"dd>dd*d-d=d,dddd d6dddeleeffffffffgiimiZiwi`iTiui0iiJihiki^iSiyii]ici[kGkrkkkknnnnnnnnnnnnnnnnnnnnnnqNqYqiqdqIqgq\qlqfqLqeq^qFqhqVr:rRs7sEs?s>totZtUt_t^tAt?tYt[t\uvuxvuvuuuuuuvvw[wkwfw^wcwywjwlw\wewhwbwxxxxxxx|xxxyzyy,yzzz zzzzz{w{{`{n{g|||}}y}}}}[nijrVXqpxenskyzfGw=1ufkIl[<5acimF^\_ Y߈Ԉو܈؈݈ʈՈ҉krsfip|cqmbnly{>hbʌnjȌČ̌ōߍ掲 KJSBTAljiɒ7W8=@>[KdQ4IME9?Z͖˖ɖʖVtv  鞂 PPPPPPPPPPPPQbQRRS1SUVVVUVVV V VUVVVVUWWXuX~XXXXyXX}XY%Y"Y$YjYiZZZZZZZ[u[[[[[[[[[\ \b]]^[^c^U^W^T^^_ _F_p_aGa?aKawabaca_aZaXaub*ddXdTddxd_dzdQdgd4dmd{ereeefffiiiiiiiiiiiiiiiiiiikIkLl3o3onono)o>o o,ooo"nnoo1o8o2o#oo+o/oo*nonnnqqq}qqqr>rrsDsPtdtctjtptmuuv'v v v vvvww}wwaxxxxxxyyyz.z1zzzz{{{{u{{{{{{{|||}}}}}}}}}}}}}}}}}}}p߀^ZPKɄƄĄ˄ӄфʇ?;"%4U7)jӌьҍk`X\cY^b][uxwtx{|̖җ| AB󞼟;JQQPPPQQQ QQRRRRRRSV.V;V9V2V?V4V)VSVNVWVtV6V/V0XXXXXXXXYm[ Z[ Z[ [[[[[\d\e]]^b^_^a^^^^^^_H_q__avagana]aUaa|apaka~aaaaaaaaab.didodyddddddddddddddddddeuewexffffj#jijjjij!jj ijjijkPkNkkko?o|ooQofoToomo[oxonoozopodooXnooo`o_qqqqrVrsNsWtittt~tuv v)vv$v&v!v"vvvwwwwwxxxxxxxxz?z~F~7~2~C~+~=~1~E~A~4~9~H~5~?~/DqrposƁÁɁ q~gч҇Ƈȇˉ;6D8= A?sIKHJD>BE?}9M(uJeK~l[pZTʕ˕̕ȕƖ֗ӘF5;?Ϟޞܞݞ۟>KSVVXX[8_]ab3dddedddefg&jjjjjjjjk_kxkp p opoppqqqqswsuttuvVvXvRwwwwyyzazbz`zz|+|'|*||#|!|~T~U~^~Z~a~R~YHwv́ς υͅЅɅ(9,+PYcfd_UIMГԕ֕ЕՖܖٖۖޗ$MOLNS>?=.ONMʛɛțQ]`,Q3VXXX[^aaaaeeffjjjjppp(pppprr rXrsxsztttuuv_vawyyzkzi|>|?|8|=|7|@~k~m~y~i~j~s؅݅Յ `_V^A\XIZNOFY |rvlztTNѓߓÓȓܓݓ͓֓ؓדܖ*'aܗ^X[EI ֛۝arjlRVVVVVX[@[C[}[]aaeeefg'jp>p0p2rs{tvbvey&y*y,y+zz|L|C|M||~}~|~Lڂf  dplfo_k ˔0ęRQ+075 y/_caQ7Q8VVVY\l]aaeeefjkjkpLrrttviw|P~~-#"!jltw}_.35:82+892geWEC@>ϛTQ-%\fgQ×kUUMқI1>;ӝן4ljV]be#e+e*fktz|d|c|e~~~8?1c`dho\Z[WӚԚќTWV垟VXe,p^vqvrwP69bwjBHDƘp_"X_|}wr^kpc|l|n;rpq^֛#pdwڋwɚbe~Ŕ}~|wxTr(j1|r00000A0B0C0D0E0F0G0H0I0J0K0L0M0N0O0P0Q0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z0{0|0}0~00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000#$%&'()*+,-./012345Q6789:;<=>?@ABCDEFGHIJKLMNO$`$a$b$c$d$e$f$g$h$i$t$u$v$w$x$y$z${$|$}NBN\QSSNN NGNV \n_sNQNN.NNNNQRSlSW YY,\]ekklr?N1Ng9g8g;g:g?gOgORO_OAOXO-O3O?OaQQRRR!RRS ScSrSST0T7T*TTTETTT%TT=TOTAT(T$TGVVVWAWEWLWIWKWRYY@YYYYYYYYYY[[\(\*\\\\\\\\\\]^ ^^^^^^___x_v______________`_b:bbbbbbbqb{bzbpbbbwb}brbte7eeeeegEgGgYgUgLgHg]gMgZgKklllxlglkllllqlolillmllllflslel{lptpzrcrrrrrrrsssssu:u9uuvy=4xɏ0(/-N3OO|OO}OOOvOtOOOwOLOOjOOyOOxOOOOOOOOkOnQQQR5R2R3RFR1RS S SuuvvvvvwwwwwwyBy?yzxz{z|u|5 ‚ÂpomnVҏˏӏ͏֏Տא9=<:COOOOOOOOOOOOOOOOOOORDRIRRS=S|SSSSTTTTTTà TTTTTTTTpTTTTrTTWWWWWWWWWWWWWWWXY YSYYYZYYYYYYYYYYYYYYYYY[\L\\\\\\\\\\\\\\\\\\\\]^!^"^#^ ^$^^^^^^__._V_`7`9`T`r`^`E`S`G`I`[`L`@`B`_`$`D`X`f`nbBbCbc c bccbbcc bbcccbcbbeAeCeef6f!f2f5ff&f"f3f+f:ff4f9f.ggggggggggggggggggggggggggggggggggggggggggk(kkkkkkl l!m(m4m-mm9/%3-DQ%V?A&"BN*ZMZ9ZLZpZiZGZQZVZBZ\[r[n[[\Y]] ]]] ] ](] ]&]%]]0]]#]].^>^4^^^^^_6_8___`````````````````````c2ceccc}ccccccccocccnccuccmcc|cc;ccxcccccpeSefefaf[fYf\fbghyhhhhmhnhhiVhohhhhuhthhhwhh|hkhrhhhqh~hhhhhhhxh{hhhh}k6k3k7k8kkkkkl*mmmmntmmmmmmnmmmmmmmmmmmmmmmmmmmmmmmmmmmpq pqpq pqpqppqqqppq qqr~r{r|rssssss srssssssttsttssst t studucuuuuuuuvvvw9w/w-w1w2w4w3w=w%w;w5xHxRxIxMxJxLx&xExPydygyiyjycykyayyyyyzzz{5{G{4{%{0{"{${3{{*{{1{+{-{/{2{8{{#||||}5}=}8}6}:}E},})}A}G}>}?}J};}(cɀGCH%-,!'"83:42tzstu}~vYV†ņȆ̆ÆR։ىՊ0',9;\]}}{y؎ގݎ܎׎$  !ԐVXZSUz|mkqoj噗PPPPPPPPPPPhPPPPQ_QSSSSUUUUUwVEUUUUUUUUUU}UUUUUUW X)X7XXX'X#X(WXHX%XXX3X?X6X.X9X8X-X,X;YaZZZZzZZZxZZ|ZZZZZ7ZZZZZZZ{Z}ZZZZZ[[[[[[[\ \0]7]C]k]A]K]?]5]Q]N]U]3]:]R]=]1]Y]B]9]I]8]<]2]6]@]E^D^A_X___``````a`a aa`a````aaaa`aa bJccccccccdcccccccdaccccccccccccccce2egejede\eheeeeeeeef|flf{ffqfyfjfrgi hihi*hhhihhhhhiihhihiiphihhihhhhhi i ihhhhhhhihhii%hk9k;k?k?ef׀QOPԁCJROG=M:<=?u;σ#ƃȃヿ݃؃˃΃փɄ ބƒՃǃуÃă׃ۃ؆ӆچ݆܆׆шHVU׈ɉ݉ډۊNM9Y@WXDERHQJLO_؍Ӎ͍Ǎ֍܍ύՍٍȍ׍Ŏ-4/,ad_b` %& '${~–ȖÖlpnNNNPPPPPPPPPPPPPPPPPQRzRxR{R|UUUUUUUUUUUUUUUUUUUUUUUWXSXhXdXOXMXIXoXUXNX]XYXeX[X=XcXqXZZZZZZZZZZZZZZZZZZZZ[[[\\3]q]c]J]e]r]l]^]h]g]b]^O^N^J^M^K^^^^^_@__`aIaJa+aEa6a2a.aFa/aOa)a@b hb#b%b$cccddd d d$d3dCdddd9d7d"d#d d&d0d(dAd5d/d dd@d%d'd cdd.d!deoeefffffffffxg ifi_i8iNibiqi?iEiji9iBiWiYiziHiIi5ili3i=iehixi4iii@ioiDiviXiAitiLi;iKi7i\iOiQi2iRi/i{iF 2*-<:15B&'8$0뉝芫=hiՌό׍   # "$!zrysvzy}~-X}z~{Ηٙ͘ǚ>?`a_PQQ0PQQPPQ Q PQ RRRRVHVBVLV5VAVJVIVFVXVZV@V3V=V,V>V8V*V:WXXXXXXXXXXZZZZZ[Z[Z[[[[\g]]]]]]]]]]]]^i^]^`^\}^^^_I_aaayaaaaaaaaaaaaaafab-dndpddddddddddddhddevezeye{eefffffffjjjiijiij iiijjij'iijiij@jiij iij jjj%jij&jijkQkkkkllkloAo&o~oooooooboOooZoovolooUoroRoPoWooo]ooaoko}ogooSooiooocowojo{qqqqqqqqqqqqqqqqqrrsXsRs^s_s`s]s[sasZsYsbtttttt}ttt|tyuuu~v%vvvvv#vv(vvvvvwwwwxxxxxxxxxxxyyyyyykvz9zzz{{{{{{{{{||||}}}}}}~}}}}}}}vdgOSRPNQ$;)  '+ *(.1& 0 /bVcdwsXT[RaZQ^mjPN_]olzn\eO{ubgiZ   ϊƊӊъԊՊ׊Ŋ؊Êٌ>Mߌٌڌ݌獠 #%$.&',$ #spogk/+)*2&.ВÒĒْϒߒؒגݒ̒’ʒȒΒ͒Ւɒޒђƒ|ӗZЗϘ&)( 'ܙ͙ϙәԙΙəؙ֙˙י̚FCgtqfvuphdlӟQQQQQQS4SVpV`VnVsVfVcVmVrV^VwWWXXXXXXXX[[[[![[[[[([[ [[]]]]]]]]]]]]]^g^h^f^o^^^^^_K_aaaaaaaaaaaaddddddddddde3ee|effffffffffg#j4jfjIjgj2jhj>j]jmjvj[jQj(jZj;j?jAjjjdjPjOjTjojij`j[qNnuUg`f]Telcedy&0-.'1")#/,݋ߊȊފln3>8@E6<=A0?6.52974vy{356'z8<#F- ˓%4$)95* ͕ԗ 5/2$')皹3|~{z}% )"՞֞=Q&Q%Q"Q$Q Q)RVVVVVVV~VVVXXXX[-[%[2[#[,['[&[/[.[{[[]^l^j__aaaaaaaaaddddddeeeefjjjjjjjjjjjjjjjjjjjjjjjk[kl ooooooooooooooqqqqqqqsssnsotttttttttuuuuuvCvHvIvGvvwwwwwwwwwxxyxxxyxxyyyz\z[zVzXzTzZzzz||{|{{|{| {|| ||{{|{{|| |~-~<~B~3H~8~*~I~@~G~)~L~0~;~6~D~:E~},ā́ʁŁǁ[Z\{w|zxWyvhŇɇLJ̇ćʇއ53<>AR7B " OprqooNMSPLGC@~8dVG|X\vIPQ`mLjyWUROqw{a^cgNYǕɕÕŕ ՗ԗADJIEC%+,*32/-10H3Ag6./180EBC>7@=-Ȟڞ$#"TQ1Q-Q.VVVVVVYp[<\i\j]^m^naaaaaaaaaadeddeedeefffjjjjjjjjjjjk^kl pp p ppppopop&oop rqqrqsvttttttttuuv\vdvYvPvSvWvZvvvwwxy yyy yyyyyz_||)|| ||-||&|(|"|%|0~\~P~V~c~X~b~_~Q~`~W~SuсЂ_^ƅŅDžą˅΅ȅŅ҆$iۇ߇ԇ܇Ӈ؇㇤ׇو݉SKOLFPQI*'#305G/<>1%7&6.$;=:Bu\b`WV^eg[Za]iTFGHK(:;>ҕӕіז]–ߖؖݗ#"%חٗ֗ؗPQRA<:  ܛ)5JLKǛƛÛӛě\SOJ[KYVLWRT_XZߟ%+*)(LUQ4Q5RRSVVVVVVXXXY[=[>[?]^p_aeee e e eeeefjjjjjjjjjjjjjk`kl pp'p pp+p!p"p#p)pp$pp*r r rrrrrrrrttttuv`wwwwyyy!yyyyzgzh|3|<|9|,|;||~v~u~x~p~w~o~z~r~t~hKJxׁՂdacمڅׅ؅߅܅хޅ  bZ[Wa\X]YPHJ@SVTKUQBRWCwv mxsjo{RQOPS@?ޓǓϓ“ړГ̓ٓʓԓՓēΓғ}ڕۖ)+,(&ݗޗߘ\Y]WHGC%$" '#›  7ޛԛכܛٛ՛ڝwqx}ktupis{oyh-@AMVWXS7VVVX[E]]^^__aeeeeefffjjjjjjjjp02.3vtsEdcbU]W^ėŘVY RXPJMKUYLNžО876COqpnoVV[N\me-ffkp_pap]p`r#ttwy8yy|j~mC875K”khiFCGǗ^՛Ycgfb^` FtuvVe.ekkkkpbr&rwwy9|i|k|~~~~FGHyz|{nmoqsIr_hnm  Gx{zyWpf|o<Ôtxvu`tsqu phpe|j>=?ɗKst̙adfg$Hbkr'Lih.r)Kyvukzpipj~IPKM]GG"Parser/Encodings/x-sjis-jdk117.encnu6$x-sjis-jdk117(%  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~abcdefghijklmnopqrstuvwxyz{|}~\@@OL@@^@c@ @@@W@@@@ K@ @ @ @ ?@ @ @v@3@@@j@'@@@^@@@@R@@@@F@@e\~ abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'000 000@>?00000N0000  \0 \ & %     00;=[]00 0 0 0 0 0000 ""`"f"g""4&B&@ 2 3! &&%%%%%%%%%%% ;0!!!!0"" """""*")"'"(!!""" "#"""a"R"j"k""=""5"+",!+ 0&o&m&j !%!"#$%&'()*+,-./0123456789:ABCDEFGHIJKLMNOPQRSTUVWXYZ0A0B0C0D0E0F0G0H0I0J0K0L0M0N0O0P0Q0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z0{0|0}0~00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 !"#$%&'()*+,-./012345Q6789:;<=>?@ABCDEFGHIJKLMNO%%% %%%%%,%$%4%<%%%%%%%#%3%+%;%K% %/%(%7%?%%0%%%8%BNUZ?Tac(Y"uzP`cn%efhW'ebq[YІ{}b}b|[^c fhHǗgONO OMOPIVY7YZ\ `aapfipuOupy}}ÄcUzS;NNW߀xNXn8z2(/QASpTTVY_m-bpT S[p–So\zNxn&VUk;YSmftܕVBNKO SU[0_qf fhl8lm)t[vzN4[`muvʙ`iSQWX0YD[^`(cclopqqYqs?~vх`[XielZu%QY.Ye__bej*k'ksV,\l{Q\KahvraNYOSx`in)zON SNOUO=OOsRSV YZ[[yfggkLlpksyyz<{ۃwӇfV)NO\brYu;傽řNOVXJX^_`*``babbe9AffhmwppuLv}uQRYT[]ahimxˈWrmlWgΒRVT^bdhkSlWo"ooEtuvw z{|!}6f̌Qeә(N8T+\]svLw<\ TXOOSqUVhWYG[ [\^ ^~_cg:eeghhj_^0kll}uyH[cz}_w̏Z/__`hjtZxwN^NO|OPPQIQlRRRSSTTUWQWY}[T[][]]]^x^^^_`RaLbbce;ffCfgmh!hil_m*min/nu2vxlz?|}}}^}T*RLaʑuqx?M؝;R[RSTXboj_QKR;TJVz@w`sDo pu_`ښrۏkdNVWdXZZ`haffh9hmu}:nBNOPSU]o]]gltsxPWP^c+PPQgTX^Y[_ibMch=ksnp}rxx&yme}0܈ RdW(gPjQWB*X:iT]WxO\RJTd>f(ggz{V}"/h\{9SQR7[bddg-kvcLvfRN PS\q`dech_qsu#{~ۑxefkNNO:OR:SSUVXYYY[P\M^^+_`ce/[\eeegkbk{lsEyIy|}}+󉖊^ifnjܖ̘koNOtuxy: 3ꄔlP_X+z[NSWY1Z[`nou[{Prg\aJ~Q\chfeqny>}ʐnǐPR\:gSp|r5Lȓ+[_1`N;S[bKg1krsz.kRQSTj[cj9}VSTh[\1]Oabm2yy}B~MҁFrt/1KlƑNOOQESA_bglAn sc~&͒SY[my]~.|X~qQSO\f%wzQ_eiokmnodv}]uQRb@ffn^}rfRSYs^_`UdPQRS SGSTUFU1VYhYZ<[\\\\^^^_pbbbccwff f-fvg~hjj5lmn nXq d_xRbcdBb-z{}v INQHSCS`[\\]b&bGdhh4lmEmgo\qNq}ez{}~Jz9n΍xwRMUo8q6Qhy~U|VLXQ\cffiZruuyyVy|} }D4;a PRuSSP UXYOr=[\dS``c\cc?cdef]iioqNuvz|}}aIXlōpmPXaӅ5 OPtRGSs`ocIg_n,O\^e}SRQvc[X[k\ d gQ\NYY*lpQU>XY`bSg5iU@Ě(OSX[\^/_` aKb4flnހ΁Ԉ.ۛNSY'{,Lnp'SSUD[bXbblot"8o8QSSOFTYj1]zꏿhڌ7rHj=N9SXVWfbcekNmn[pwz{}=Ɔˊ[VX_>efjku7P$wW0_`efzl`uznE{u\z{Qyz6Zw@N-N[_bft6x4ZFuO^bceWgovrL̀)MP WZhisqdrXjyw)O/ReSZbglv}{|6fo r~Q{xr{{Hj^auQu`QkbnvzOpb{OVzXY䖼O4R$SJSS^d,egl>lNrHrsuT~A,錩{đqic=fiujvxЅCS*SQT&Y^_|`bIbybekluvxy}w^j |8P\>_gkt5w ;gzS9u_f_<_ub{Feg llpx2~+ނ *JҘlNONPRVWJY^=__b?fgghQ}!~2T ,SPS\Xdg4rgwfzFRlkX^LYTg,QvdixTWYf'gkTi^UggRh]NOSbg+lO~mNabno+Tsg*E]{\[ƇnJzY|lw RY"q!r_wۗ'ai ZZQT T}fvߏYr]nQMh}}bdxj!Y[_ksv}Q2g(vgbR\$b;|~UO`} SN_QYr:6_%wS_y}3Vg󅮔Sa alvR8U/OQQ*RS[^}`acg gngms6s7u1yPՊJćYNOYN?P^|Y[^ccdfiJim nqu(zIɉ! e} a~bk2lmtmge}o#,TBojp2RZA^_gi|imjorbr{~KQmy2P-Tqkjā`gNNkhin~xU_ NNN*N1N6NzYUYPYNYZYXYbY`YgYlYiYxYYO^OYYYYYYYYZ%ZZZZ ZZ@ZlZIZ5Z6ZbZjZZZZZZZZZZZZZ[ [ [[2Z[*[6[>[C[E[@[Q[U[Z[[[e[i[p[s[u[xe[z[[[[[[[[[[[[[[[[[[\\\\ \\ \"\(\8\9\A\F\N\S\P\O[q\l\nNb\v\y\\\Y\\\\\\\\\\\\\]\] ]]]\]]]]]"]]]]L]R]N]K]l]s]v]]]]]]]]]]]]]]]]]]]]^ ^^^^^6^7^D^C^@^N^W^T^_^b^d^G^u^v^z^^^^^^^^^^^^^^^^^^^^^^^__ _]_\_ ___)_-_8_A_H_L_N_/_Q_V_W_Y_a_m_s_w____________________`_`!`````)``1```+`&``:`Z`A`j`w`_`J`F`M`c`C`d`B`l`k`Y`````````````````_````aMaa``a``aa!``a aaGa>a(a'aJa?acMdcOcccccvcccccckcicccccccccdd4ddd&d6edd(ddgdodvdNe*ddddddddddddddd ddbdde,ddddedeeee$e#e+e4e5e7e6e8uKeHeVeUeMeXe^e]erexeeeeeeeeeeeeeeeeegrf fegsf5f6f4ffOfDfIfAf^f]fdfgfhf_fbfpffffffffffffffffff?fffffgggg&g'8g.g?g6gAg8g7gFg^g`gYgcgdggpgg|gjgggggggggggggggggggggjhhFh)h@hMh2hNhh+hYhchwhhhhhhhhjhhthhhihh~ihihi"i&hi hhhhi6iihhi%hhhi(i*ii#i!hiyiwi\ixikiTi~ini9iti=iYi0iai^i]iijiiiiiiii[iiiiij.iiiiiiijjik iiijijijij jjj#jjDj jrj6jxjGjbjYjfjHj8j"jjjjjjjjjjjjjjjjjjjjkjkk1kk8k7vk9kGkCkIkPkYkTk[k_kakxkykkkkkkkkkkkkkkkkkkkkkkkkklllll$l#l^lUlbljllllll~lhlslllllllllllllllllmMm6m+m=m8mm5m3mm mcmmdmZmymYmmommnn mmmmmmmmmmmmmmmmmn-nnn.nnrn_n>n#nkn+nvnMnnCn:nNn$nnn8nnnnnnnnnnnnnnnnoAopLnnno?no1no2no>onoozoxooooo[oomoo|oXoooofooooooooooooooop p opppoppotpppp0p>p2pQpcppppppppppppq pqqqeqUqqfqbqLqVqlqqqqqqqqqqqqqqqqqqqqr rrr(r-r,r0r2r;rsNsOsWsjshspsxsus{szsssssssstttot%st2t:tUt?t_tYtAt\titptctjtvt~ttttttsttttttttttuuuu uu uuuu&u,uz7zCzWzIzazbzizpzyz}zzzzzzzzzzzzzzzzzzzzzzzzzz{{{ {{3{{{{5{({6{P{z{{M{ {L{E{u{e{t{g{p{q{l{n{{{{{{{{{{]{{{{{{{{{||{{|`|||{{|| {|#|'|*||7|+|=|L|C|T|O|@|P|X|_|d|V|e|l|u|||||||||||||||||||||;|||||}}}}} }E}K}.}2}?}5}F}s}V}N}r}h}n}O}c}}}[}}}}}}}}}}}~=}}}}}}}}}}}}}~~ ~#~!~~1~~ ~ ~"~F~f~;~5~9~C~7~2~:~g~]~V~^~Y~Z~y~j~i~|~{~}~}~~~~~~~~~~~~8:ELMNPQUTX_`higxq܀ !(?;JFRXZ_bhsrpvy}Qۀـ݀Āڀց )#/KF>SQqneft_Ɂ́сف؁ȁځ߁ )+83@YX]Z_dbhjk.qwx~߂҂ރ܃ ك5421@9PE/+#|su΃؄  " 8m*(ALONIV[Zk_lot}:A?HLNPUblxz|bȌڌ  N͍gmqsύڍ֍̍ۍˍߍ B504JGILPHYd`*cUvr|ƎŎȎˎێ  &3;9EB>LIFNW\bcdڏ!  '659OPQRI>VX^hovr}bHۑ20JVXceisrɑˑБ֑ߑۑ,^WEIdH?KPZϒD."#:5;\`|nV֓דؓÓݓГȓ6+5!:ARD[`b^j)puw}Z|~oÕ͕̕Օԕ֕ܕ!(./BLOKw\^]_frlΖ˖ɖ͉Mܗ Ֆ$*09=>DFHBI\`dfhRҗkqy|z×Ɨȗ˗ܗOzߗ 8$!7=FOKkopqtsĘØƘ !$ ,.=>BIEPKQRLUߙۙݙؙљ+7EB@C>UM[W_bedikjϚњӚԚޚߚ"#%'()*./2DCOMNQXtʛƛϛћқԛ:   .%$!0G2F>Z`gvx *&#DA?>FH]^dQPYrozĝƝϝٝӝuy}a̞ΞϞОԞܞޞݞv!,>JRTc_`afgljwrvX/iǐYtdQqPKM](^R00Parser/Encodings/iso-8859-4.encnu6$ISO-8859-4  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~8V(;`"f}W)<a#gJ~K. *EL6rhj/ +FM7sikPKM]OPPParser/Expat.pmnu6$package XML::Parser::Expat; use strict; #use warnings; No warnings numeric?? use XSLoader; use Carp; our $VERSION = '2.46'; our ( %Encoding_Table, @Encoding_Path, $have_File_Spec ); use File::Spec (); %Encoding_Table = (); if ($have_File_Spec) { @Encoding_Path = ( grep( -d $_, map( File::Spec->catdir( $_, qw(XML Parser Encodings) ), @INC ) ), File::Spec->curdir ); } else { @Encoding_Path = ( grep( -d $_, map( $_ . '/XML/Parser/Encodings', @INC ) ), '.' ); } XSLoader::load( 'XML::Parser::Expat', $VERSION ); our %Handler_Setters = ( Start => \&SetStartElementHandler, End => \&SetEndElementHandler, Char => \&SetCharacterDataHandler, Proc => \&SetProcessingInstructionHandler, Comment => \&SetCommentHandler, CdataStart => \&SetStartCdataHandler, CdataEnd => \&SetEndCdataHandler, Default => \&SetDefaultHandler, Unparsed => \&SetUnparsedEntityDeclHandler, Notation => \&SetNotationDeclHandler, ExternEnt => \&SetExternalEntityRefHandler, ExternEntFin => \&SetExtEntFinishHandler, Entity => \&SetEntityDeclHandler, Element => \&SetElementDeclHandler, Attlist => \&SetAttListDeclHandler, Doctype => \&SetDoctypeHandler, DoctypeFin => \&SetEndDoctypeHandler, XMLDecl => \&SetXMLDeclHandler ); sub new { my ( $class, %args ) = @_; my $self = bless \%args, $_[0]; $args{_State_} = 0; $args{Context} = []; $args{Namespaces} ||= 0; $args{ErrorMessage} ||= ''; if ( $args{Namespaces} ) { $args{Namespace_Table} = {}; $args{Namespace_List} = [undef]; $args{Prefix_Table} = {}; $args{New_Prefixes} = []; } $args{_Setters} = \%Handler_Setters; $args{Parser} = ParserCreate( $self, $args{ProtocolEncoding}, $args{Namespaces} ); $self; } sub load_encoding { my ($file) = @_; $file =~ s!([^/]+)$!\L$1\E!; $file .= '.enc' unless $file =~ /\.enc$/; unless ( $file =~ m!^/! ) { foreach (@Encoding_Path) { my $tmp = ( $have_File_Spec ? File::Spec->catfile( $_, $file ) : "$_/$file" ); if ( -e $tmp ) { $file = $tmp; last; } } } open( my $fh, '<', $file ) or croak("Couldn't open encmap $file:\n$!\n"); binmode($fh); my $data; my $br = sysread( $fh, $data, -s $file ); croak("Trouble reading $file:\n$!\n") unless defined($br); close($fh); my $name = LoadEncoding( $data, $br ); croak("$file isn't an encmap file") unless defined($name); $name; } # End load_encoding sub setHandlers { my ( $self, @handler_pairs ) = @_; croak("Uneven number of arguments to setHandlers method") if ( int(@handler_pairs) & 1 ); my @ret; while (@handler_pairs) { my $type = shift @handler_pairs; my $handler = shift @handler_pairs; croak 'Handler for $type not a Code ref' unless ( !defined($handler) or !$handler or ref($handler) eq 'CODE' ); my $hndl = $self->{_Setters}->{$type}; unless ( defined($hndl) ) { my @types = sort keys %{ $self->{_Setters} }; croak("Unknown Expat handler type: $type\n Valid types: @types"); } my $old = &$hndl( $self->{Parser}, $handler ); push( @ret, $type, $old ); } return @ret; } sub xpcroak { my ( $self, $message ) = @_; my $eclines = $self->{ErrorContext}; my $line = GetCurrentLineNumber( $_[0]->{Parser} ); $message .= " at line $line"; $message .= ":\n" . $self->position_in_context($eclines) if defined($eclines); croak $message; } sub xpcarp { my ( $self, $message ) = @_; my $eclines = $self->{ErrorContext}; my $line = GetCurrentLineNumber( $_[0]->{Parser} ); $message .= ' at line $line'; $message .= ":\n" . $self->position_in_context($eclines) if defined($eclines); carp $message; } sub default_current { my $self = shift; if ( $self->{_State_} == 1 ) { return DefaultCurrent( $self->{Parser} ); } } sub recognized_string { my $self = shift; if ( $self->{_State_} == 1 ) { return RecognizedString( $self->{Parser} ); } } sub original_string { my $self = shift; if ( $self->{_State_} == 1 ) { return OriginalString( $self->{Parser} ); } } sub current_line { my $self = shift; if ( $self->{_State_} == 1 ) { return GetCurrentLineNumber( $self->{Parser} ); } } sub current_column { my $self = shift; if ( $self->{_State_} == 1 ) { return GetCurrentColumnNumber( $self->{Parser} ); } } sub current_byte { my $self = shift; if ( $self->{_State_} == 1 ) { return GetCurrentByteIndex( $self->{Parser} ); } } sub base { my ( $self, $newbase ) = @_; my $p = $self->{Parser}; my $oldbase = GetBase($p); SetBase( $p, $newbase ) if @_ > 1; return $oldbase; } sub context { my $ctx = $_[0]->{Context}; @$ctx; } sub current_element { my ($self) = @_; @{ $self->{Context} } ? $self->{Context}->[-1] : undef; } sub in_element { my ( $self, $element ) = @_; @{ $self->{Context} } ? $self->eq_name( $self->{Context}->[-1], $element ) : undef; } sub within_element { my ( $self, $element ) = @_; my $cnt = 0; foreach ( @{ $self->{Context} } ) { $cnt++ if $self->eq_name( $_, $element ); } return $cnt; } sub depth { my ($self) = @_; int( @{ $self->{Context} } ); } sub element_index { my ($self) = @_; if ( $self->{_State_} == 1 ) { return ElementIndex( $self->{Parser} ); } } ################ # Namespace methods sub namespace { my ( $self, $name ) = @_; local ($^W) = 0; $self->{Namespace_List}->[ int($name) ]; } sub eq_name { my ( $self, $nm1, $nm2 ) = @_; local ($^W) = 0; int($nm1) == int($nm2) and $nm1 eq $nm2; } sub generate_ns_name { my ( $self, $name, $namespace ) = @_; $namespace ? GenerateNSName( $name, $namespace, $self->{Namespace_Table}, $self->{Namespace_List} ) : $name; } sub new_ns_prefixes { my ($self) = @_; if ( $self->{Namespaces} ) { return @{ $self->{New_Prefixes} }; } return (); } sub expand_ns_prefix { my ( $self, $prefix ) = @_; if ( $self->{Namespaces} ) { my $stack = $self->{Prefix_Table}->{$prefix}; return ( defined($stack) and @$stack ) ? $stack->[-1] : undef; } return undef; } sub current_ns_prefixes { my ($self) = @_; if ( $self->{Namespaces} ) { my %set = %{ $self->{Prefix_Table} }; if ( exists $set{'#default'} and not defined( $set{'#default'}->[-1] ) ) { delete $set{'#default'}; } return keys %set; } return (); } ################################################################ # Namespace declaration handlers # sub NamespaceStart { my ( $self, $prefix, $uri ) = @_; $prefix = '#default' unless defined $prefix; my $stack = $self->{Prefix_Table}->{$prefix}; if ( defined $stack ) { push( @$stack, $uri ); } else { $self->{Prefix_Table}->{$prefix} = [$uri]; } # The New_Prefixes list gets emptied at end of startElement function # in Expat.xs push( @{ $self->{New_Prefixes} }, $prefix ); } sub NamespaceEnd { my ( $self, $prefix ) = @_; $prefix = '#default' unless defined $prefix; my $stack = $self->{Prefix_Table}->{$prefix}; if ( @$stack > 1 ) { pop(@$stack); } else { delete $self->{Prefix_Table}->{$prefix}; } } ################ sub specified_attr { my $self = shift; if ( $self->{_State_} == 1 ) { return GetSpecifiedAttributeCount( $self->{Parser} ); } } sub finish { my ($self) = @_; if ( $self->{_State_} == 1 ) { my $parser = $self->{Parser}; UnsetAllHandlers($parser); } } sub position_in_context { my ( $self, $lines ) = @_; if ( $self->{_State_} == 1 ) { my $parser = $self->{Parser}; my ( $string, $linepos ) = PositionContext( $parser, $lines ); return '' unless defined($string); my $col = GetCurrentColumnNumber($parser); my $ptr = ( '=' x ( $col - 1 ) ) . '^' . "\n"; my $ret; my $dosplit = $linepos < length($string); $string .= "\n" unless $string =~ /\n$/; if ($dosplit) { $ret = substr( $string, 0, $linepos ) . $ptr . substr( $string, $linepos ); } else { $ret = $string . $ptr; } return $ret; } } sub xml_escape { my $self = shift; my $text = shift; study $text; $text =~ s/\&/\&/g; $text =~ s/ 1; if ( $_ eq '>' ) { $text =~ s/>/\>/g; } elsif ( $_ eq '"' ) { $text =~ s/\"/\"/; } elsif ( $_ eq "'" ) { $text =~ s/\'/\'/; } else { my $rep = '&#' . sprintf( 'x%X', ord($_) ) . ';'; if (/\W/) { my $ptrn = "\\$_"; $text =~ s/$ptrn/$rep/g; } else { $text =~ s/$_/$rep/g; } } } $text; } sub skip_until { my $self = shift; if ( $self->{_State_} <= 1 ) { SkipUntil( $self->{Parser}, $_[0] ); } } sub release { my $self = shift; ParserRelease( $self->{Parser} ); } sub DESTROY { my $self = shift; ParserFree( $self->{Parser} ); } sub parse { my $self = shift; my $arg = shift; croak 'Parse already in progress (Expat)' if $self->{_State_}; $self->{_State_} = 1; my $parser = $self->{Parser}; my $ioref; my $result = 0; if ( defined $arg ) { local *@; if ( ref($arg) and UNIVERSAL::isa( $arg, 'IO::Handle' ) ) { $ioref = $arg; } elsif ( $] < 5.008 and defined tied($arg) ) { require IO::Handle; $ioref = $arg; } else { require IO::Handle; eval { no strict 'refs'; $ioref = *{$arg}{IO} if defined *{$arg}; }; if ( ref($ioref) eq 'FileHandle' ) { #for perl 5.10.x and possibly earlier, see t/file_open_scalar.t require FileHandle; } } } if ( defined($ioref) ) { my $delim = $self->{Stream_Delimiter}; my $prev_rs; my $ioclass = ref $ioref; $ioclass = 'IO::Handle' if !length $ioclass; $prev_rs = $ioclass->input_record_separator("\n$delim\n") if defined($delim); $result = ParseStream( $parser, $ioref, $delim ); $ioclass->input_record_separator($prev_rs) if defined($delim); } else { $result = ParseString( $parser, $arg ); } $self->{_State_} = 2; $result or croak $self->{ErrorMessage}; } sub parsestring { my $self = shift; $self->parse(@_); } sub parsefile { my $self = shift; croak 'Parser has already been used' if $self->{_State_}; open( my $fh, '<', $_[0] ) or croak "Couldn't open $_[0]:\n$!"; binmode($fh); my $ret = $self->parse($fh); close($fh); $ret; } ################################################################ package #hide from PAUSE XML::Parser::ContentModel; use overload '""' => \&asString, 'eq' => \&thiseq; sub EMPTY () { 1 } sub ANY () { 2 } sub MIXED () { 3 } sub NAME () { 4 } sub CHOICE () { 5 } sub SEQ () { 6 } sub isempty { return $_[0]->{Type} == EMPTY; } sub isany { return $_[0]->{Type} == ANY; } sub ismixed { return $_[0]->{Type} == MIXED; } sub isname { return $_[0]->{Type} == NAME; } sub name { return $_[0]->{Tag}; } sub ischoice { return $_[0]->{Type} == CHOICE; } sub isseq { return $_[0]->{Type} == SEQ; } sub quant { return $_[0]->{Quant}; } sub children { my $children = $_[0]->{Children}; if ( defined $children ) { return @$children; } return undef; } sub asString { my ($self) = @_; my $ret; if ( $self->{Type} == NAME ) { $ret = $self->{Tag}; } elsif ( $self->{Type} == EMPTY ) { return 'EMPTY'; } elsif ( $self->{Type} == ANY ) { return 'ANY'; } elsif ( $self->{Type} == MIXED ) { $ret = '(#PCDATA'; foreach ( @{ $self->{Children} } ) { $ret .= '|' . $_; } $ret .= ')'; } else { my $sep = $self->{Type} == CHOICE ? '|' : ','; $ret = '(' . join( $sep, map { $_->asString } @{ $self->{Children} } ) . ')'; } $ret .= $self->{Quant} if $self->{Quant}; return $ret; } sub thiseq { my $self = shift; return $self->asString eq $_[0]; } ################################################################ package #hide from PAUSE XML::Parser::ExpatNB; use Carp; our @ISA = qw(XML::Parser::Expat); sub parse { my $self = shift; my $class = ref($self); croak "parse method not supported in $class"; } sub parsestring { my $self = shift; my $class = ref($self); croak "parsestring method not supported in $class"; } sub parsefile { my $self = shift; my $class = ref($self); croak "parsefile method not supported in $class"; } sub parse_more { my ( $self, $data ) = @_; $self->{_State_} = 1; my $ret = XML::Parser::Expat::ParsePartial( $self->{Parser}, $data ); croak $self->{ErrorMessage} unless $ret; } sub parse_done { my $self = shift; my $ret = XML::Parser::Expat::ParseDone( $self->{Parser} ); unless ($ret) { my $msg = $self->{ErrorMessage}; $self->release; croak $msg; } $self->{_State_} = 2; my $result = $ret; my @result = (); my $final = $self->{FinalHandler}; if ( defined $final ) { if (wantarray) { @result = &$final($self); } else { $result = &$final($self); } } $self->release; return unless defined wantarray; return wantarray ? @result : $result; } ################################################################ package #hide from PAUSE XML::Parser::Encinfo; sub DESTROY { my $self = shift; XML::Parser::Expat::FreeEncoding($self); } 1; __END__ =head1 NAME XML::Parser::Expat - Lowlevel access to James Clark's expat XML parser =head1 SYNOPSIS use XML::Parser::Expat; $parser = XML::Parser::Expat->new; $parser->setHandlers('Start' => \&sh, 'End' => \&eh, 'Char' => \&ch); open(my $fh, '<', 'info.xml') or die "Couldn't open"; $parser->parse($fh); close($fh); # $parser->parse(' here we go '); sub sh { my ($p, $el, %atts) = @_; $p->setHandlers('Char' => \&spec) if ($el eq 'special'); ... } sub eh { my ($p, $el) = @_; $p->setHandlers('Char' => \&ch) # Special elements won't contain if ($el eq 'special'); # other special elements ... } =head1 DESCRIPTION This module provides an interface to James Clark's XML parser, expat. As in expat, a single instance of the parser can only parse one document. Calls to parsestring after the first for a given instance will die. Expat (and XML::Parser::Expat) are event based. As the parser recognizes parts of the document (say the start or end of an XML element), then any handlers registered for that type of an event are called with suitable parameters. =head1 METHODS =over 4 =item new This is a class method, the constructor for XML::Parser::Expat. Options are passed as keyword value pairs. The recognized options are: =over 4 =item * ProtocolEncoding The protocol encoding name. The default is none. The expat built-in encodings are: C, C, C, and C. Other encodings may be used if they have encoding maps in one of the directories in the @Encoding_Path list. Setting the protocol encoding overrides any encoding in the XML declaration. =item * Namespaces When this option is given with a true value, then the parser does namespace processing. By default, namespace processing is turned off. When it is turned on, the parser consumes I attributes and strips off prefixes from element and attributes names where those prefixes have a defined namespace. A name's namespace can be found using the L<"namespace"> method and two names can be checked for absolute equality with the L<"eq_name"> method. =item * NoExpand Normally, the parser will try to expand references to entities defined in the internal subset. If this option is set to a true value, and a default handler is also set, then the default handler will be called when an entity reference is seen in text. This has no effect if a default handler has not been registered, and it has no effect on the expansion of entity references inside attribute values. =item * Stream_Delimiter This option takes a string value. When this string is found alone on a line while parsing from a stream, then the parse is ended as if it saw an end of file. The intended use is with a stream of xml documents in a MIME multipart format. The string should not contain a trailing newline. =item * ErrorContext When this option is defined, errors are reported in context. The value of ErrorContext should be the number of lines to show on either side of the line in which the error occurred. =item * ParseParamEnt Unless standalone is set to "yes" in the XML declaration, setting this to a true value allows the external DTD to be read, and parameter entities to be parsed and expanded. =item * Base The base to use for relative pathnames or URLs. This can also be done by using the base method. =back =item setHandlers(TYPE, HANDLER [, TYPE, HANDLER [...]]) This method registers handlers for the various events. If no handlers are registered, then a call to parsestring or parsefile will only determine if the corresponding XML document is well formed (by returning without error.) This may be called from within a handler, after the parse has started. Setting a handler to something that evaluates to false unsets that handler. This method returns a list of type, handler pairs corresponding to the input. The handlers returned are the ones that were in effect before the call to setHandlers. The recognized events and the parameters passed to the corresponding handlers are: =over 4 =item * Start (Parser, Element [, Attr, Val [,...]]) This event is generated when an XML start tag is recognized. Parser is an XML::Parser::Expat instance. Element is the name of the XML element that is opened with the start tag. The Attr & Val pairs are generated for each attribute in the start tag. =item * End (Parser, Element) This event is generated when an XML end tag is recognized. Note that an XML empty tag () generates both a start and an end event. There is always a lower level start and end handler installed that wrap the corresponding callbacks. This is to handle the context mechanism. A consequence of this is that the default handler (see below) will not see a start tag or end tag unless the default_current method is called. =item * Char (Parser, String) This event is generated when non-markup is recognized. The non-markup sequence of characters is in String. A single non-markup sequence of characters may generate multiple calls to this handler. Whatever the encoding of the string in the original document, this is given to the handler in UTF-8. =item * Proc (Parser, Target, Data) This event is generated when a processing instruction is recognized. =item * Comment (Parser, String) This event is generated when a comment is recognized. =item * CdataStart (Parser) This is called at the start of a CDATA section. =item * CdataEnd (Parser) This is called at the end of a CDATA section. =item * Default (Parser, String) This is called for any characters that don't have a registered handler. This includes both characters that are part of markup for which no events are generated (markup declarations) and characters that could generate events, but for which no handler has been registered. Whatever the encoding in the original document, the string is returned to the handler in UTF-8. =item * Unparsed (Parser, Entity, Base, Sysid, Pubid, Notation) This is called for a declaration of an unparsed entity. Entity is the name of the entity. Base is the base to be used for resolving a relative URI. Sysid is the system id. Pubid is the public id. Notation is the notation name. Base and Pubid may be undefined. =item * Notation (Parser, Notation, Base, Sysid, Pubid) This is called for a declaration of notation. Notation is the notation name. Base is the base to be used for resolving a relative URI. Sysid is the system id. Pubid is the public id. Base, Sysid, and Pubid may all be undefined. =item * ExternEnt (Parser, Base, Sysid, Pubid) This is called when an external entity is referenced. Base is the base to be used for resolving a relative URI. Sysid is the system id. Pubid is the public id. Base, and Pubid may be undefined. This handler should either return a string, which represents the contents of the external entity, or return an open filehandle that can be read to obtain the contents of the external entity, or return undef, which indicates the external entity couldn't be found and will generate a parse error. If an open filehandle is returned, it must be returned as either a glob (*FOO) or as a reference to a glob (e.g. an instance of IO::Handle). =item * ExternEntFin (Parser) This is called after an external entity has been parsed. It allows applications to perform cleanup on actions performed in the above ExternEnt handler. =item * Entity (Parser, Name, Val, Sysid, Pubid, Ndata, IsParam) This is called when an entity is declared. For internal entities, the Val parameter will contain the value and the remaining three parameters will be undefined. For external entities, the Val parameter will be undefined, the Sysid parameter will have the system id, the Pubid parameter will have the public id if it was provided (it will be undefined otherwise), the Ndata parameter will contain the notation for unparsed entities. If this is a parameter entity declaration, then the IsParam parameter is true. Note that this handler and the Unparsed handler above overlap. If both are set, then this handler will not be called for unparsed entities. =item * Element (Parser, Name, Model) The element handler is called when an element declaration is found. Name is the element name, and Model is the content model as an XML::Parser::ContentModel object. See L<"XML::Parser::ContentModel Methods"> for methods available for this class. =item * Attlist (Parser, Elname, Attname, Type, Default, Fixed) This handler is called for each attribute in an ATTLIST declaration. So an ATTLIST declaration that has multiple attributes will generate multiple calls to this handler. The Elname parameter is the name of the element with which the attribute is being associated. The Attname parameter is the name of the attribute. Type is the attribute type, given as a string. Default is the default value, which will either be "#REQUIRED", "#IMPLIED" or a quoted string (i.e. the returned string will begin and end with a quote character). If Fixed is true, then this is a fixed attribute. =item * Doctype (Parser, Name, Sysid, Pubid, Internal) This handler is called for DOCTYPE declarations. Name is the document type name. Sysid is the system id of the document type, if it was provided, otherwise it's undefined. Pubid is the public id of the document type, which will be undefined if no public id was given. Internal will be true or false, indicating whether or not the doctype declaration contains an internal subset. =item * DoctypeFin (Parser) This handler is called after parsing of the DOCTYPE declaration has finished, including any internal or external DTD declarations. =item * XMLDecl (Parser, Version, Encoding, Standalone) This handler is called for XML declarations. Version is a string containing the version. Encoding is either undefined or contains an encoding string. Standalone is either undefined, or true or false. Undefined indicates that no standalone parameter was given in the XML declaration. True or false indicates "yes" or "no" respectively. =back =item namespace(name) Return the URI of the namespace that the name belongs to. If the name doesn't belong to any namespace, an undef is returned. This is only valid on names received through the Start or End handlers from a single document, or through a call to the generate_ns_name method. In other words, don't use names generated from one instance of XML::Parser::Expat with other instances. =item eq_name(name1, name2) Return true if name1 and name2 are identical (i.e. same name and from the same namespace.) This is only meaningful if both names were obtained through the Start or End handlers from a single document, or through a call to the generate_ns_name method. =item generate_ns_name(name, namespace) Return a name, associated with a given namespace, good for using with the above 2 methods. The namespace argument should be the namespace URI, not a prefix. =item new_ns_prefixes When called from a start tag handler, returns namespace prefixes declared with this start tag. If called elsewhere (or if there were no namespace prefixes declared), it returns an empty list. Setting of the default namespace is indicated with '#default' as a prefix. =item expand_ns_prefix(prefix) Return the uri to which the given prefix is currently bound. Returns undef if the prefix isn't currently bound. Use '#default' to find the current binding of the default namespace (if any). =item current_ns_prefixes Return a list of currently bound namespace prefixes. The order of the the prefixes in the list has no meaning. If the default namespace is currently bound, '#default' appears in the list. =item recognized_string Returns the string from the document that was recognized in order to call the current handler. For instance, when called from a start handler, it will give us the start-tag string. The string is encoded in UTF-8. This method doesn't return a meaningful string inside declaration handlers. =item original_string Returns the verbatim string from the document that was recognized in order to call the current handler. The string is in the original document encoding. This method doesn't return a meaningful string inside declaration handlers. =item default_current When called from a handler, causes the sequence of characters that generated the corresponding event to be sent to the default handler (if one is registered). Use of this method is deprecated in favor the recognized_string method, which you can use without installing a default handler. This method doesn't deliver a meaningful string to the default handler when called from inside declaration handlers. =item xpcroak(message) Concatenate onto the given message the current line number within the XML document plus the message implied by ErrorContext. Then croak with the formed message. =item xpcarp(message) Concatenate onto the given message the current line number within the XML document plus the message implied by ErrorContext. Then carp with the formed message. =item current_line Returns the line number of the current position of the parse. =item current_column Returns the column number of the current position of the parse. =item current_byte Returns the current position of the parse. =item base([NEWBASE]); Returns the current value of the base for resolving relative URIs. If NEWBASE is supplied, changes the base to that value. =item context Returns a list of element names that represent open elements, with the last one being the innermost. Inside start and end tag handlers, this will be the tag of the parent element. =item current_element Returns the name of the innermost currently opened element. Inside start or end handlers, returns the parent of the element associated with those tags. =item in_element(NAME) Returns true if NAME is equal to the name of the innermost currently opened element. If namespace processing is being used and you want to check against a name that may be in a namespace, then use the generate_ns_name method to create the NAME argument. =item within_element(NAME) Returns the number of times the given name appears in the context list. If namespace processing is being used and you want to check against a name that may be in a namespace, then use the generate_ns_name method to create the NAME argument. =item depth Returns the size of the context list. =item element_index Returns an integer that is the depth-first visit order of the current element. This will be zero outside of the root element. For example, this will return 1 when called from the start handler for the root element start tag. =item skip_until(INDEX) INDEX is an integer that represents an element index. When this method is called, all handlers are suspended until the start tag for an element that has an index number equal to INDEX is seen. If a start handler has been set, then this is the first tag that the start handler will see after skip_until has been called. =item position_in_context(LINES) Returns a string that shows the current parse position. LINES should be an integer >= 0 that represents the number of lines on either side of the current parse line to place into the returned string. =item xml_escape(TEXT [, CHAR [, CHAR ...]]) Returns TEXT with markup characters turned into character entities. Any additional characters provided as arguments are also turned into character references where found in TEXT. =item parse (SOURCE) The SOURCE parameter should either be a string containing the whole XML document, or it should be an open IO::Handle. Only a single document may be parsed for a given instance of XML::Parser::Expat, so this will croak if it's been called previously for this instance. =item parsestring(XML_DOC_STRING) Parses the given string as an XML document. Only a single document may be parsed for a given instance of XML::Parser::Expat, so this will die if either parsestring or parsefile has been called for this instance previously. This method is deprecated in favor of the parse method. =item parsefile(FILENAME) Parses the XML document in the given file. Will die if parsestring or parsefile has been called previously for this instance. =item is_defaulted(ATTNAME) NO LONGER WORKS. To find out if an attribute is defaulted please use the specified_attr method. =item specified_attr When the start handler receives lists of attributes and values, the non-defaulted (i.e. explicitly specified) attributes occur in the list first. This method returns the number of specified items in the list. So if this number is equal to the length of the list, there were no defaulted values. Otherwise the number points to the index of the first defaulted attribute name. =item finish Unsets all handlers (including internal ones that set context), but expat continues parsing to the end of the document or until it finds an error. It should finish up a lot faster than with the handlers set. =item release There are data structures used by XML::Parser::Expat that have circular references. This means that these structures will never be garbage collected unless these references are explicitly broken. Calling this method breaks those references (and makes the instance unusable.) Normally, higher level calls handle this for you, but if you are using XML::Parser::Expat directly, then it's your responsibility to call it. =back =head2 XML::Parser::ContentModel Methods The element declaration handlers are passed objects of this class as the content model of the element declaration. They also represent content particles, components of a content model. When referred to as a string, these objects are automagicly converted to a string representation of the model (or content particle). =over 4 =item isempty This method returns true if the object is "EMPTY", false otherwise. =item isany This method returns true if the object is "ANY", false otherwise. =item ismixed This method returns true if the object is "(#PCDATA)" or "(#PCDATA|...)*", false otherwise. =item isname This method returns if the object is an element name. =item ischoice This method returns true if the object is a choice of content particles. =item isseq This method returns true if the object is a sequence of content particles. =item quant This method returns undef or a string representing the quantifier ('?', '*', '+') associated with the model or particle. =item children This method returns undef or (for mixed, choice, and sequence types) an array of component content particles. There will always be at least one component for choices and sequences, but for a mixed content model of pure PCDATA, "(#PCDATA)", then an undef is returned. =back =head2 XML::Parser::ExpatNB Methods The class XML::Parser::ExpatNB is a subclass of XML::Parser::Expat used for non-blocking access to the expat library. It does not support the parse, parsestring, or parsefile methods, but it does have these additional methods: =over 4 =item parse_more(DATA) Feed expat more text to munch on. =item parse_done Tell expat that it's gotten the whole document. =back =head1 FUNCTIONS =over 4 =item XML::Parser::Expat::load_encoding(ENCODING) Load an external encoding. ENCODING is either the name of an encoding or the name of a file. The basename is converted to lowercase and a '.enc' extension is appended unless there's one already there. Then, unless it's an absolute pathname (i.e. begins with '/'), the first file by that name discovered in the @Encoding_Path path list is used. The encoding in the file is loaded and kept in the %Encoding_Table table. Earlier encodings of the same name are replaced. This function is automatically called by expat when it encounters an encoding it doesn't know about. Expat shouldn't call this twice for the same encoding name. The only reason users should use this function is to explicitly load an encoding not contained in the @Encoding_Path list. =back =head1 AUTHORS Larry Wall > wrote version 1.0. Clark Cooper > picked up support, changed the API for this version (2.x), provided documentation, and added some standard package features. =cut PKM]/G--Parser/Style/Stream.pmnu6$# $Id: Stream.pm,v 1.1 2003-07-27 16:07:49 matt Exp $ package XML::Parser::Style::Stream; use strict; # This style invented by Tim Bray sub Init { no strict 'refs'; my $expat = shift; $expat->{Text} = ''; my $sub = $expat->{Pkg} . "::StartDocument"; &$sub($expat) if defined(&$sub); } sub Start { no strict 'refs'; my $expat = shift; my $type = shift; doText($expat); $_ = "<$type"; %_ = @_; while (@_) { $_ .= ' ' . shift() . '="' . shift() . '"'; } $_ .= '>'; my $sub = $expat->{Pkg} . "::StartTag"; if ( defined(&$sub) ) { &$sub( $expat, $type ); } else { print; } } sub End { no strict 'refs'; my $expat = shift; my $type = shift; # Set right context for Text handler push( @{ $expat->{Context} }, $type ); doText($expat); pop( @{ $expat->{Context} } ); $_ = ""; my $sub = $expat->{Pkg} . "::EndTag"; if ( defined(&$sub) ) { &$sub( $expat, $type ); } else { print; } } sub Char { my $expat = shift; $expat->{Text} .= shift; } sub Proc { no strict 'refs'; my $expat = shift; my $target = shift; my $text = shift; doText($expat); $_ = ""; my $sub = $expat->{Pkg} . "::PI"; if ( defined(&$sub) ) { &$sub( $expat, $target, $text ); } else { print; } } sub Final { no strict 'refs'; my $expat = shift; my $sub = $expat->{Pkg} . "::EndDocument"; &$sub($expat) if defined(&$sub); } sub doText { no strict 'refs'; my $expat = shift; $_ = $expat->{Text}; if ( length($_) ) { my $sub = $expat->{Pkg} . "::Text"; if ( defined(&$sub) ) { &$sub($expat); } else { print; } $expat->{Text} = ''; } } 1; __END__ =head1 NAME XML::Parser::Style::Stream - Stream style for XML::Parser =head1 SYNOPSIS use XML::Parser; my $p = XML::Parser->new(Style => 'Stream', Pkg => 'MySubs'); $p->parsefile('foo.xml'); { package MySubs; sub StartTag { my ($e, $name) = @_; # do something with start tags } sub EndTag { my ($e, $name) = @_; # do something with end tags } sub Characters { my ($e, $data) = @_; # do something with text nodes } } =head1 DESCRIPTION This style uses the Pkg option to find subs in a given package to call for each event. If none of the subs that this style looks for is there, then the effect of parsing with this style is to print a canonical copy of the document without comments or declarations. All the subs receive as their 1st parameter the Expat instance for the document they're parsing. It looks for the following routines: =over 4 =item * StartDocument Called at the start of the parse . =item * StartTag Called for every start tag with a second parameter of the element type. The $_ variable will contain a copy of the tag and the %_ variable will contain attribute values supplied for that element. =item * EndTag Called for every end tag with a second parameter of the element type. The $_ variable will contain a copy of the end tag. =item * Text Called just before start or end tags with accumulated non-markup text in the $_ variable. =item * PI Called for processing instructions. The $_ variable will contain a copy of the PI and the target and data are sent as 2nd and 3rd parameters respectively. =item * EndDocument Called at conclusion of the parse. =back =cut PKM]G$dParser/Style/Tree.pmnu6$# $Id: Tree.pm,v 1.2 2003-07-31 07:54:51 matt Exp $ package XML::Parser::Style::Tree; $XML::Parser::Built_In_Styles{Tree} = 1; sub Init { my $expat = shift; $expat->{Lists} = []; $expat->{Curlist} = $expat->{Tree} = []; } sub Start { my $expat = shift; my $tag = shift; my $newlist = [ {@_} ]; push @{ $expat->{Lists} }, $expat->{Curlist}; push @{ $expat->{Curlist} }, $tag => $newlist; $expat->{Curlist} = $newlist; } sub End { my $expat = shift; my $tag = shift; $expat->{Curlist} = pop @{ $expat->{Lists} }; } sub Char { my $expat = shift; my $text = shift; my $clist = $expat->{Curlist}; my $pos = $#$clist; if ( $pos > 0 and $clist->[ $pos - 1 ] eq '0' ) { $clist->[$pos] .= $text; } else { push @$clist, 0 => $text; } } sub Final { my $expat = shift; delete $expat->{Curlist}; delete $expat->{Lists}; $expat->{Tree}; } 1; __END__ =head1 NAME XML::Parser::Style::Tree - Tree style parser =head1 SYNOPSIS use XML::Parser; my $p = XML::Parser->new(Style => 'Tree'); my $tree = $p->parsefile('foo.xml'); =head1 DESCRIPTION This module implements XML::Parser's Tree style parser. When parsing a document, C will return a parse tree for the document. Each node in the tree takes the form of a tag, content pair. Text nodes are represented with a pseudo-tag of "0" and the string that is their content. For elements, the content is an array reference. The first item in the array is a (possibly empty) hash reference containing attributes. The remainder of the array is a sequence of tag-content pairs representing the content of the element. So for example the result of parsing: Hello thereHowdydo would be: Tag Content ================================================================== [foo, [{}, head, [{id => "a"}, 0, "Hello ", em, [{}, 0, "there"]], bar, [ {}, 0, "Howdy", ref, [{}]], 0, "do" ] ] The root document "foo", has 3 children: a "head" element, a "bar" element and the text "do". After the empty attribute hash, these are represented in it's contents by 3 tag-content pairs. =cut PKM]_QParser/Style/Subs.pmnu6$# $Id: Subs.pm,v 1.1 2003-07-27 16:07:49 matt Exp $ package XML::Parser::Style::Subs; sub Start { no strict 'refs'; my $expat = shift; my $tag = shift; my $sub = $expat->{Pkg} . "::$tag"; eval { &$sub( $expat, $tag, @_ ) }; } sub End { no strict 'refs'; my $expat = shift; my $tag = shift; my $sub = $expat->{Pkg} . "::${tag}_"; eval { &$sub( $expat, $tag ) }; } 1; __END__ =head1 NAME XML::Parser::Style::Subs - glue for handling element callbacks =head1 SYNOPSIS use XML::Parser; my $p = XML::Parser->new(Style => 'Subs', Pkg => 'MySubs'); $p->parsefile('foo.xml'); { package MySubs; sub foo { # start of foo tag } sub foo_ { # end of foo tag } } =head1 DESCRIPTION Each time an element starts, a sub by that name in the package specified by the Pkg option is called with the same parameters that the Start handler gets called with. Each time an element ends, a sub with that name appended with an underscore ("_"), is called with the same parameters that the End handler gets called with. Nothing special is returned by parse. =cut PKM]$JJParser/Style/Objects.pmnu6$# $Id: Objects.pm,v 1.1 2003-08-18 20:20:51 matt Exp $ package XML::Parser::Style::Objects; use strict; sub Init { my $expat = shift; $expat->{Lists} = []; $expat->{Curlist} = $expat->{Tree} = []; } sub Start { my $expat = shift; my $tag = shift; my $newlist = []; my $class = "${$expat}{Pkg}::$tag"; my $newobj = bless { @_, Kids => $newlist }, $class; push @{ $expat->{Lists} }, $expat->{Curlist}; push @{ $expat->{Curlist} }, $newobj; $expat->{Curlist} = $newlist; } sub End { my $expat = shift; my $tag = shift; $expat->{Curlist} = pop @{ $expat->{Lists} }; } sub Char { my $expat = shift; my $text = shift; my $class = "${$expat}{Pkg}::Characters"; my $clist = $expat->{Curlist}; my $pos = $#$clist; if ( $pos >= 0 and ref( $clist->[$pos] ) eq $class ) { $clist->[$pos]->{Text} .= $text; } else { push @$clist, bless { Text => $text }, $class; } } sub Final { my $expat = shift; delete $expat->{Curlist}; delete $expat->{Lists}; $expat->{Tree}; } 1; __END__ =head1 NAME XML::Parser::Style::Objects - Objects styler parser =head1 SYNOPSIS use XML::Parser; my $p = XML::Parser->new(Style => 'Objects', Pkg => 'MyNode'); my $tree = $p->parsefile('foo.xml'); =head1 DESCRIPTION This module implements XML::Parser's Objects style parser. This is similar to the Tree style, except that a hash object is created for each element. The corresponding object will be in the class whose name is created by appending "::" and the element name to the package set with the Pkg option. Non-markup text will be in the ::Characters class. The contents of the corresponding object will be in an anonymous array that is the value of the Kids property for that object. =head1 SEE ALSO L =cut PKM]yParser/Style/Debug.pmnu6$# $Id: Debug.pm,v 1.1 2003-07-27 16:07:49 matt Exp $ package XML::Parser::Style::Debug; use strict; sub Start { my $expat = shift; my $tag = shift; print STDERR "@{$expat->{Context}} \\\\ (@_)\n"; } sub End { my $expat = shift; my $tag = shift; print STDERR "@{$expat->{Context}} //\n"; } sub Char { my $expat = shift; my $text = shift; $text =~ s/([\x80-\xff])/sprintf "#x%X;", ord $1/eg; $text =~ s/([\t\n])/sprintf "#%d;", ord $1/eg; print STDERR "@{$expat->{Context}} || $text\n"; } sub Proc { my $expat = shift; my $target = shift; my $text = shift; my @foo = @{ $expat->{Context} }; print STDERR "@foo $target($text)\n"; } 1; __END__ =head1 NAME XML::Parser::Style::Debug - Debug style for XML::Parser =head1 SYNOPSIS use XML::Parser; my $p = XML::Parser->new(Style => 'Debug'); $p->parsefile('foo.xml'); =head1 DESCRIPTION This just prints out the document in outline form to STDERR. Nothing special is returned by parse. =cut PKM]T..Parser/LWPExternEnt.plnu6$# LWPExternEnt.pl # # Copyright (c) 2000 Clark Cooper # All rights reserved. # # This program is free software; you can redistribute it and/or # modify it under the same terms as Perl itself. package XML::Parser; use URI; use URI::file; use LWP::UserAgent; ## ## Note that this external entity handler reads the entire entity into ## memory, so it will choke on huge ones. It would be really nice if ## LWP::UserAgent optionally returned us an IO::Handle. ## sub lwp_ext_ent_handler { my ($xp, $base, $sys) = @_; # We don't use public id my $uri; if (defined $base) { # Base may have been set by parsefile, which is agnostic about # whether its a file or URI. my $base_uri = new URI($base); unless (defined $base_uri->scheme) { $base_uri = URI->new_abs($base_uri, URI::file->cwd); } $uri = URI->new_abs($sys, $base_uri); } else { $uri = new URI($sys); unless (defined $uri->scheme) { $uri = URI->new_abs($uri, URI::file->cwd); } } my $ua = $xp->{_lwpagent}; unless (defined $ua) { $ua = $xp->{_lwpagent} = new LWP::UserAgent(); $ua->env_proxy(); } my $req = new HTTP::Request('GET', $uri); my $res = $ua->request($req); if ($res->is_error) { $xp->{ErrorMessage} .= "\n" . $res->status_line . " $uri"; return undef; } $xp->{_BaseStack} ||= []; push(@{$xp->{_BaseStack}}, $base); $xp->base($uri); return $res->content; } # End lwp_ext_ent_handler sub lwp_ext_ent_cleanup { my ($xp) = @_; $xp->base(pop(@{$xp->{_BaseStack}})); } # End lwp_ext_ent_cleanup 1; PKM]%   LibXML.pmnu6$# $Id$ # # # This is free software, you may use it and distribute it under the same terms as # Perl itself. # # Copyright 2001-2003 AxKit.com Ltd., 2002-2006 Christian Glahn, 2006-2009 Petr Pajas # # package XML::LibXML; use strict; use warnings; our ( $VERSION, $skipDTD, $skipXMLDeclaration, $setTagCompression, $MatchCB, $ReadCB, $OpenCB, $CloseCB, ); use Carp; use constant XML_XMLNS_NS => 'http://www.w3.org/2000/xmlns/'; use constant XML_XML_NS => 'http://www.w3.org/XML/1998/namespace'; use XML::LibXML::Error; use XML::LibXML::NodeList; use XML::LibXML::XPathContext; use IO::Handle; # for FH reads called as methods BEGIN { $VERSION = "2.0213"; # VERSION TEMPLATE: DO NOT CHANGE our $ABI_VERSION = 2; require Exporter; use XSLoader (); our @ISA = qw(Exporter); sub VERSION { my $class = shift; my ($caller) = caller; my $req_abi = $ABI_VERSION; if (UNIVERSAL::can($caller,'REQUIRE_XML_LIBXML_ABI_VERSION')) { $req_abi = $caller->REQUIRE_XML_LIBXML_ABI_VERSION(); } elsif ($caller eq 'XML::LibXSLT') { # XML::LibXSLT without REQUIRE_XML_LIBXML_ABI_VERSION is an old and incompatible version $req_abi = 1; } unless ($req_abi == $ABI_VERSION) { my $ver = @_ ? ' '.$_[0] : ''; die ("This version of $caller requires XML::LibXML$ver (ABI $req_abi), which is incompatible with currently installed XML::LibXML $VERSION (ABI $ABI_VERSION). Please upgrade $caller, XML::LibXML, or both!"); } return $class->UNIVERSAL::VERSION(@_) } #-------------------------------------------------------------------------# # export information # #-------------------------------------------------------------------------# our %EXPORT_TAGS = ( all => [qw( XML_ELEMENT_NODE XML_ATTRIBUTE_NODE XML_TEXT_NODE XML_CDATA_SECTION_NODE XML_ENTITY_REF_NODE XML_ENTITY_NODE XML_PI_NODE XML_COMMENT_NODE XML_DOCUMENT_NODE XML_DOCUMENT_TYPE_NODE XML_DOCUMENT_FRAG_NODE XML_NOTATION_NODE XML_HTML_DOCUMENT_NODE XML_DTD_NODE XML_ELEMENT_DECL XML_ATTRIBUTE_DECL XML_ENTITY_DECL XML_NAMESPACE_DECL XML_XINCLUDE_END XML_XINCLUDE_START encodeToUTF8 decodeFromUTF8 XML_XMLNS_NS XML_XML_NS )], libxml => [qw( XML_ELEMENT_NODE XML_ATTRIBUTE_NODE XML_TEXT_NODE XML_CDATA_SECTION_NODE XML_ENTITY_REF_NODE XML_ENTITY_NODE XML_PI_NODE XML_COMMENT_NODE XML_DOCUMENT_NODE XML_DOCUMENT_TYPE_NODE XML_DOCUMENT_FRAG_NODE XML_NOTATION_NODE XML_HTML_DOCUMENT_NODE XML_DTD_NODE XML_ELEMENT_DECL XML_ATTRIBUTE_DECL XML_ENTITY_DECL XML_NAMESPACE_DECL XML_XINCLUDE_END XML_XINCLUDE_START )], encoding => [qw( encodeToUTF8 decodeFromUTF8 )], ns => [qw( XML_XMLNS_NS XML_XML_NS )], ); our @EXPORT_OK = ( @{$EXPORT_TAGS{all}}, ); our @EXPORT = ( @{$EXPORT_TAGS{all}}, ); #-------------------------------------------------------------------------# # initialization of the global variables # #-------------------------------------------------------------------------# $skipDTD = 0; $skipXMLDeclaration = 0; $setTagCompression = 0; $MatchCB = undef; $ReadCB = undef; $OpenCB = undef; $CloseCB = undef; # if ($threads::threads) { # our $__THREADS_TID = 0; # eval q{ # use threads::shared; # our $__PROXY_NODE_REGISTRY_MUTEX :shared = 0; # }; # die $@ if $@; # } #-------------------------------------------------------------------------# # bootstrapping # #-------------------------------------------------------------------------# XSLoader::load( 'XML::LibXML', $VERSION ); undef &AUTOLOAD; *encodeToUTF8 = \&XML::LibXML::Common::encodeToUTF8; *decodeFromUTF8 = \&XML::LibXML::Common::decodeFromUTF8; } # BEGIN #-------------------------------------------------------------------------# # libxml2 node names (see also XML::LibXML::Common # #-------------------------------------------------------------------------# use constant XML_ELEMENT_NODE => 1; use constant XML_ATTRIBUTE_NODE => 2; use constant XML_TEXT_NODE => 3; use constant XML_CDATA_SECTION_NODE => 4; use constant XML_ENTITY_REF_NODE => 5; use constant XML_ENTITY_NODE => 6; use constant XML_PI_NODE => 7; use constant XML_COMMENT_NODE => 8; use constant XML_DOCUMENT_NODE => 9; use constant XML_DOCUMENT_TYPE_NODE => 10; use constant XML_DOCUMENT_FRAG_NODE => 11; use constant XML_NOTATION_NODE => 12; use constant XML_HTML_DOCUMENT_NODE => 13; use constant XML_DTD_NODE => 14; use constant XML_ELEMENT_DECL => 15; use constant XML_ATTRIBUTE_DECL => 16; use constant XML_ENTITY_DECL => 17; use constant XML_NAMESPACE_DECL => 18; use constant XML_XINCLUDE_START => 19; use constant XML_XINCLUDE_END => 20; our ($__PROXY_NODE_REGISTRY, $__threads_shared, $__PROXY_NODE_REGISTRY_MUTEX, $__loaded); sub import { my $package=shift; if (grep /^:threads_shared$/, @_) { require threads; if (!defined($__threads_shared)) { if (INIT_THREAD_SUPPORT()) { eval q{ use threads::shared; share($__PROXY_NODE_REGISTRY_MUTEX); }; if ($@) { # something went wrong DISABLE_THREAD_SUPPORT(); # leave the library in a usable state die $@; # and die } $__PROXY_NODE_REGISTRY = XML::LibXML::HashTable->new(); $__threads_shared=1; } else { croak("XML::LibXML or Perl compiled without ithread support!"); } } elsif (!$__threads_shared) { croak("XML::LibXML already loaded without thread support. Too late to enable thread support!"); } } elsif (defined $__loaded) { $__threads_shared=0 if not defined $__threads_shared; } __PACKAGE__->export_to_level(1,$package,grep !/^:threads(_shared)?$/,@_); } sub threads_shared_enabled { return $__threads_shared ? 1 : 0; } # if ($threads::threads) { # our $__PROXY_NODE_REGISTRY = XML::LibXML::HashTable->new(); # } #-------------------------------------------------------------------------# # test exact version (up to patch-level) # #-------------------------------------------------------------------------# { my ($runtime_version) = LIBXML_RUNTIME_VERSION() =~ /^(\d+)/; if ( $runtime_version < LIBXML_VERSION ) { warn "Warning: XML::LibXML compiled against libxml2 ".LIBXML_VERSION. ", but runtime libxml2 is older $runtime_version\n"; } } #-------------------------------------------------------------------------# # parser flags # #-------------------------------------------------------------------------# # Copied directly from http://xmlsoft.org/html/libxml-parser.html#xmlParserOption use constant { XML_PARSE_RECOVER => 1, # recover on errors XML_PARSE_NOENT => 2, # substitute entities XML_PARSE_DTDLOAD => 4, # load the external subset XML_PARSE_DTDATTR => 8, # default DTD attributes XML_PARSE_DTDVALID => 16, # validate with the DTD XML_PARSE_NOERROR => 32, # suppress error reports XML_PARSE_NOWARNING => 64, # suppress warning reports XML_PARSE_PEDANTIC => 128, # pedantic error reporting XML_PARSE_NOBLANKS => 256, # remove blank nodes XML_PARSE_SAX1 => 512, # use the SAX1 interface internally XML_PARSE_XINCLUDE => 1024, # Implement XInclude substitution XML_PARSE_NONET => 2048, # Forbid network access XML_PARSE_NODICT => 4096, # Do not reuse the context dictionary XML_PARSE_NSCLEAN => 8192, # remove redundant namespaces declarations XML_PARSE_NOCDATA => 16384, # merge CDATA as text nodes XML_PARSE_NOXINCNODE => 32768, # do not generate XINCLUDE START/END nodes XML_PARSE_COMPACT => 65536, # compact small text nodes; no modification of the tree allowed afterwards # (will possibly crash if you try to modify the tree) XML_PARSE_OLD10 => 131072, # parse using XML-1.0 before update 5 XML_PARSE_NOBASEFIX => 262144, # do not fixup XINCLUDE xml#base uris XML_PARSE_HUGE => 524288, # relax any hardcoded limit from the parser XML_PARSE_OLDSAX => 1048576, # parse using SAX2 interface from before 2.7.0 HTML_PARSE_RECOVER => (1<<0), # suppress error reports HTML_PARSE_NOERROR => (1<<5), # suppress error reports }; our $XML_LIBXML_PARSE_DEFAULTS = ( XML_PARSE_NODICT ); # this hash is made global so that applications can add names for new # libxml2 parser flags as temporary workaround our %PARSER_FLAGS = ( recover => XML_PARSE_RECOVER, expand_entities => XML_PARSE_NOENT, load_ext_dtd => XML_PARSE_DTDLOAD, complete_attributes => XML_PARSE_DTDATTR, validation => XML_PARSE_DTDVALID, suppress_errors => XML_PARSE_NOERROR, suppress_warnings => XML_PARSE_NOWARNING, pedantic_parser => XML_PARSE_PEDANTIC, no_blanks => XML_PARSE_NOBLANKS, expand_xinclude => XML_PARSE_XINCLUDE, xinclude => XML_PARSE_XINCLUDE, no_network => XML_PARSE_NONET, clean_namespaces => XML_PARSE_NSCLEAN, no_cdata => XML_PARSE_NOCDATA, no_xinclude_nodes => XML_PARSE_NOXINCNODE, old10 => XML_PARSE_OLD10, no_base_fix => XML_PARSE_NOBASEFIX, huge => XML_PARSE_HUGE, oldsax => XML_PARSE_OLDSAX, ); my %OUR_FLAGS = ( recover => 'XML_LIBXML_RECOVER', line_numbers => 'XML_LIBXML_LINENUMBERS', URI => 'XML_LIBXML_BASE_URI', base_uri => 'XML_LIBXML_BASE_URI', gdome => 'XML_LIBXML_GDOME', ext_ent_handler => 'ext_ent_handler', ); sub _parser_options { my ($self, $opts) = @_; # currently dictionaries break XML::LibXML memory management my $flags; if (ref($self)) { $flags = ($self->{XML_LIBXML_PARSER_OPTIONS}||0); } else { $flags = $XML_LIBXML_PARSE_DEFAULTS; # safety precaution } my ($key, $value); while (($key,$value) = each %$opts) { my $f = $PARSER_FLAGS{ $key }; if (defined $f) { if ($value) { $flags |= $f } else { $flags &= ~$f; } } elsif ($key eq 'set_parser_flags') { # this can be used to pass flags XML::LibXML does not yet know about $flags |= $value; } elsif ($key eq 'unset_parser_flags') { $flags &= ~$value; } } return $flags; } my %compatibility_flags = ( XML_LIBXML_VALIDATION => 'validation', XML_LIBXML_EXPAND_ENTITIES => 'expand_entities', XML_LIBXML_PEDANTIC => 'pedantic_parser', XML_LIBXML_NONET => 'no_network', XML_LIBXML_EXT_DTD => 'load_ext_dtd', XML_LIBXML_COMPLETE_ATTR => 'complete_attributes', XML_LIBXML_EXPAND_XINCLUDE => 'expand_xinclude', XML_LIBXML_NSCLEAN => 'clean_namespaces', XML_LIBXML_KEEP_BLANKS => 'keep_blanks', XML_LIBXML_LINENUMBERS => 'line_numbers', ); #-------------------------------------------------------------------------# # parser constructor # #-------------------------------------------------------------------------# sub new { my $class = shift; my $self = bless { }, $class; if (@_) { my %opts = (); if (ref($_[0]) eq 'HASH') { %opts = %{$_[0]}; } else { # old interface my %args = @_; %opts=( map { (($compatibility_flags{ $_ }||$_) => $args{ $_ }) } keys %args ); } # parser flags $opts{no_blanks} = !$opts{keep_blanks} if exists($opts{keep_blanks}) and !exists($opts{no_blanks}); $opts{load_ext_dtd} = $opts{expand_entities} if exists($opts{expand_entities}) and !exists($opts{load_ext_dtd}); for (keys %OUR_FLAGS) { $self->{$OUR_FLAGS{$_}} = delete $opts{$_}; } $class->load_catalog(delete($opts{catalog})) if $opts{catalog}; $self->{XML_LIBXML_PARSER_OPTIONS} = XML::LibXML->_parser_options(\%opts); # store remaining unknown options directly in $self for (keys %opts) { $self->{$_}=$opts{$_} unless exists $PARSER_FLAGS{$_}; } } else { $self->{XML_LIBXML_PARSER_OPTIONS} = $XML_LIBXML_PARSE_DEFAULTS; } if ( defined $self->{Handler} ) { $self->set_handler( $self->{Handler} ); } $self->{_State_} = 0; return $self; } sub _clone { my ($self)=@_; my $new = ref($self)->new({ recover => $self->{XML_LIBXML_RECOVER}, line_numbers => $self->{XML_LIBXML_LINENUMBERS}, base_uri => $self->{XML_LIBXML_BASE_URI}, gdome => $self->{XML_LIBXML_GDOME}, }); # The parser options may contain some options that were zeroed from the # defaults so set_parser_flags won't work here. We need to assign them # explicitly. $new->{XML_LIBXML_PARSER_OPTIONS} = $self->{XML_LIBXML_PARSER_OPTIONS}; $new->input_callbacks($self->input_callbacks()); return $new; } #-------------------------------------------------------------------------# # Threads support methods # #-------------------------------------------------------------------------# # threads doc says CLONE's API may change in future, which would break # an XS method prototype sub CLONE { if ($XML::LibXML::__threads_shared) { XML::LibXML::_CLONE( $_[0] ); } } sub CLONE_SKIP { return $XML::LibXML::__threads_shared ? 0 : 1; } sub __proxy_registry { my ($class)=caller; die "This version of $class uses API of XML::LibXML 1.66 which is not compatible with XML::LibXML $VERSION. Please upgrade $class!\n"; } #-------------------------------------------------------------------------# # DOM Level 2 document constructor # #-------------------------------------------------------------------------# sub createDocument { my $self = shift; if (!@_ or $_[0] =~ m/^\d\.\d$/) { # for backward compatibility return XML::LibXML::Document->new(@_); } else { # DOM API: createDocument(namespaceURI, qualifiedName, doctype?) my $doc = XML::LibXML::Document-> new; my $el = $doc->createElementNS(shift, shift); $doc->setDocumentElement($el); $doc->setExternalSubset(shift) if @_; return $doc; } } #-------------------------------------------------------------------------# # callback functions # #-------------------------------------------------------------------------# sub externalEntityLoader(;$) { return _externalEntityLoader($_[0]); } sub input_callbacks { my $self = shift; my $icbclass = shift; if ( defined $icbclass ) { $self->{XML_LIBXML_CALLBACK_STACK} = $icbclass; } return $self->{XML_LIBXML_CALLBACK_STACK}; } sub match_callback { my $self = shift; if ( ref $self ) { if ( scalar @_ ) { $self->{XML_LIBXML_MATCH_CB} = shift; $self->{XML_LIBXML_CALLBACK_STACK} = undef; } return $self->{XML_LIBXML_MATCH_CB}; } else { $MatchCB = shift if scalar @_; return $MatchCB; } } sub read_callback { my $self = shift; if ( ref $self ) { if ( scalar @_ ) { $self->{XML_LIBXML_READ_CB} = shift; $self->{XML_LIBXML_CALLBACK_STACK} = undef; } return $self->{XML_LIBXML_READ_CB}; } else { $ReadCB = shift if scalar @_; return $ReadCB; } } sub close_callback { my $self = shift; if ( ref $self ) { if ( scalar @_ ) { $self->{XML_LIBXML_CLOSE_CB} = shift; $self->{XML_LIBXML_CALLBACK_STACK} = undef; } return $self->{XML_LIBXML_CLOSE_CB}; } else { $CloseCB = shift if scalar @_; return $CloseCB; } } sub open_callback { my $self = shift; if ( ref $self ) { if ( scalar @_ ) { $self->{XML_LIBXML_OPEN_CB} = shift; $self->{XML_LIBXML_CALLBACK_STACK} = undef; } return $self->{XML_LIBXML_OPEN_CB}; } else { $OpenCB = shift if scalar @_; return $OpenCB; } } sub callbacks { my $self = shift; if ( ref $self ) { if (@_) { my ($match, $open, $read, $close) = @_; @{$self}{qw(XML_LIBXML_MATCH_CB XML_LIBXML_OPEN_CB XML_LIBXML_READ_CB XML_LIBXML_CLOSE_CB)} = ($match, $open, $read, $close); $self->{XML_LIBXML_CALLBACK_STACK} = undef; } else { return @{$self}{qw(XML_LIBXML_MATCH_CB XML_LIBXML_OPEN_CB XML_LIBXML_READ_CB XML_LIBXML_CLOSE_CB)}; } } else { if (@_) { ( $MatchCB, $OpenCB, $ReadCB, $CloseCB ) = @_; } else { return ( $MatchCB, $OpenCB, $ReadCB, $CloseCB ); } } } #-------------------------------------------------------------------------# # internal member variable manipulation # #-------------------------------------------------------------------------# sub __parser_option { my ($self, $opt) = @_; if (@_>2) { if ($_[2]) { $self->{XML_LIBXML_PARSER_OPTIONS} |= $opt; return 1; } else { $self->{XML_LIBXML_PARSER_OPTIONS} &= ~$opt; return 0; } } else { return ($self->{XML_LIBXML_PARSER_OPTIONS} & $opt) ? 1 : 0; } } sub option_exists { my ($self,$name)=@_; return ($PARSER_FLAGS{$name} || $OUR_FLAGS{$name}) ? 1 : 0; } sub get_option { my ($self,$name)=@_; my $flag = $OUR_FLAGS{$name}; return $self->{$flag} if $flag; $flag = $PARSER_FLAGS{$name}; return $self->__parser_option($flag) if $flag; warn "XML::LibXML::get_option: unknown parser option $name\n"; return undef; } sub set_option { my ($self,$name,$value)=@_; my $flag = $OUR_FLAGS{$name}; return ($self->{$flag}=$value) if $flag; $flag = $PARSER_FLAGS{$name}; return $self->__parser_option($flag,$value) if $flag; warn "XML::LibXML::get_option: unknown parser option $name\n"; return undef; } sub set_options { my $self=shift; my $opts; if (@_==1 and ref($_[0]) eq 'HASH') { $opts = $_[0]; } elsif (@_ % 2 == 0) { $opts={@_}; } else { croak("Odd number of elements passed to set_options"); } $self->set_option($_=>$opts->{$_}) foreach keys %$opts; return; } sub validation { my $self = shift; return $self->__parser_option(XML_PARSE_DTDVALID,@_); } sub recover { my $self = shift; if (scalar @_) { $self->{XML_LIBXML_RECOVER} = $_[0]; $self->__parser_option(XML_PARSE_RECOVER,@_); } return $self->{XML_LIBXML_RECOVER}; } sub recover_silently { my $self = shift; my $arg = shift; if ( defined($arg) ) { $self->recover(($arg == 1) ? 2 : $arg); } return (($self->recover()||0) == 2) ? 1 : 0; } sub expand_entities { my $self = shift; if (scalar(@_) and $_[0]) { return $self->__parser_option(XML_PARSE_NOENT | XML_PARSE_DTDLOAD,1); } return $self->__parser_option(XML_PARSE_NOENT,@_); } sub keep_blanks { my $self = shift; my @args; # we have to negate the argument and return negated value, since # the actual flag is no_blanks if (scalar @_) { @args=($_[0] ? 0 : 1); } return $self->__parser_option(XML_PARSE_NOBLANKS,@args) ? 0 : 1; } sub pedantic_parser { my $self = shift; return $self->__parser_option(XML_PARSE_PEDANTIC,@_); } sub line_numbers { my $self = shift; $self->{XML_LIBXML_LINENUMBERS} = shift if scalar @_; return $self->{XML_LIBXML_LINENUMBERS}; } sub no_network { my $self = shift; return $self->__parser_option(XML_PARSE_NONET,@_); } sub load_ext_dtd { my $self = shift; return $self->__parser_option(XML_PARSE_DTDLOAD,@_); } sub complete_attributes { my $self = shift; return $self->__parser_option(XML_PARSE_DTDATTR,@_); } sub expand_xinclude { my $self = shift; return $self->__parser_option(XML_PARSE_XINCLUDE,@_); } sub base_uri { my $self = shift; $self->{XML_LIBXML_BASE_URI} = shift if scalar @_; return $self->{XML_LIBXML_BASE_URI}; } sub gdome_dom { my $self = shift; $self->{XML_LIBXML_GDOME} = shift if scalar @_; return $self->{XML_LIBXML_GDOME}; } sub clean_namespaces { my $self = shift; return $self->__parser_option(XML_PARSE_NSCLEAN,@_); } #-------------------------------------------------------------------------# # set the optional SAX(2) handler # #-------------------------------------------------------------------------# sub set_handler { my $self = shift; if ( defined $_[0] ) { $self->{HANDLER} = $_[0]; $self->{SAX_ELSTACK} = []; $self->{SAX} = {State => 0}; } else { # undef SAX handling $self->{SAX_ELSTACK} = []; delete $self->{HANDLER}; delete $self->{SAX}; } } #-------------------------------------------------------------------------# # helper functions # #-------------------------------------------------------------------------# sub _auto_expand { my ( $self, $result, $uri ) = @_; $result->setBaseURI( $uri ) if defined $uri; if ( $self->expand_xinclude ) { $self->{_State_} = 1; eval { $self->processXIncludes($result); }; my $err = $@; $self->{_State_} = 0; if ($err) { $self->_cleanup_callbacks(); $result = undef; croak $err; } } return $result; } sub _init_callbacks { my $self = shift; my $icb = $self->{XML_LIBXML_CALLBACK_STACK}; unless ( defined $icb ) { $self->{XML_LIBXML_CALLBACK_STACK} = XML::LibXML::InputCallback->new(); $icb = $self->{XML_LIBXML_CALLBACK_STACK}; } $icb->init_callbacks($self); } sub _cleanup_callbacks { my $self = shift; $self->{XML_LIBXML_CALLBACK_STACK}->cleanup_callbacks(); } sub __read { read($_[0], $_[1], $_[2]); } sub __write { if ( ref( $_[0] ) ) { $_[0]->write( $_[1], $_[2] ); } else { $_[0]->write( $_[1] ); } } sub load_xml { my $class_or_self = shift; my %args = map { ref($_) eq 'HASH' ? (%$_) : $_ } @_; my $URI = delete($args{URI}); $URI = "$URI" if defined $URI; # stringify in case it is an URI object my $parser; if (ref($class_or_self)) { $parser = $class_or_self->_clone(); $parser->{XML_LIBXML_PARSER_OPTIONS} = $parser->_parser_options(\%args); } else { $parser = $class_or_self->new(\%args); } my $dom; if ( defined $args{location} ) { $dom = $parser->parse_file( "$args{location}" ); } elsif ( defined $args{string} ) { $dom = $parser->parse_string( $args{string}, $URI ); } elsif ( defined $args{IO} ) { $dom = $parser->parse_fh( $args{IO}, $URI ); } else { croak("XML::LibXML->load: specify location, string, or IO"); } return $dom; } sub load_html { my ($class_or_self) = shift; my %args = map { ref($_) eq 'HASH' ? (%$_) : $_ } @_; my $URI = delete($args{URI}); $URI = "$URI" if defined $URI; # stringify in case it is an URI object my $parser; if (ref($class_or_self)) { $parser = $class_or_self->_clone(); } else { $parser = $class_or_self->new(); } my $dom; if ( defined $args{location} ) { $dom = $parser->parse_html_file( "$args{location}", \%args ); } elsif ( defined $args{string} ) { $dom = $parser->parse_html_string( $args{string}, \%args ); } elsif ( defined $args{IO} ) { $dom = $parser->parse_html_fh( $args{IO}, \%args ); } else { croak("XML::LibXML->load: specify location, string, or IO"); } return $dom; } #-------------------------------------------------------------------------# # parsing functions # #-------------------------------------------------------------------------# # all parsing functions handle normal as SAX parsing at the same time. # note that SAX parsing is handled incomplete! use XML::LibXML::SAX for # complete parsing sequences #-------------------------------------------------------------------------# sub parse_string { my $self = shift; croak("parse_string is not a class method! Create a parser object with XML::LibXML->new first!") unless ref $self; croak("parse already in progress") if $self->{_State_}; unless ( defined $_[0] and length $_[0] ) { croak("Empty String"); } $self->{_State_} = 1; my $result; $self->_init_callbacks(); if ( defined $self->{SAX} ) { my $string = shift; $self->{SAX_ELSTACK} = []; eval { $result = $self->_parse_sax_string($string); }; my $err = $@; $self->{_State_} = 0; if ($err) { chomp $err unless ref $err; $self->_cleanup_callbacks(); croak $err; } } else { eval { $result = $self->_parse_string( @_ ); }; my $err = $@; $self->{_State_} = 0; if ($err) { chomp $err unless ref $err; $self->_cleanup_callbacks(); croak $err; } $result = $self->_auto_expand( $result, $self->{XML_LIBXML_BASE_URI} ); } $self->_cleanup_callbacks(); return $result; } sub parse_fh { my $self = shift; croak("parse_fh is not a class method! Create a parser object with XML::LibXML->new first!") unless ref $self; croak("parse already in progress") if $self->{_State_}; $self->{_State_} = 1; my $result; $self->_init_callbacks(); if ( defined $self->{SAX} ) { $self->{SAX_ELSTACK} = []; eval { $self->_parse_sax_fh( @_ ); }; my $err = $@; $self->{_State_} = 0; if ($err) { chomp $err unless ref $err; $self->_cleanup_callbacks(); croak $err; } } else { eval { $result = $self->_parse_fh( @_ ); }; my $err = $@; $self->{_State_} = 0; if ($err) { chomp $err unless ref $err; $self->_cleanup_callbacks(); croak $err; } $result = $self->_auto_expand( $result, $self->{XML_LIBXML_BASE_URI} ); } $self->_cleanup_callbacks(); return $result; } sub parse_file { my $self = shift; croak("parse_file is not a class method! Create a parser object with XML::LibXML->new first!") unless ref $self; croak("parse already in progress") if $self->{_State_}; $self->{_State_} = 1; my $result; $self->_init_callbacks(); if ( defined $self->{SAX} ) { $self->{SAX_ELSTACK} = []; eval { $self->_parse_sax_file( @_ ); }; my $err = $@; $self->{_State_} = 0; if ($err) { chomp $err unless ref $err; $self->_cleanup_callbacks(); croak $err; } } else { eval { $result = $self->_parse_file(@_); }; my $err = $@; $self->{_State_} = 0; if ($err) { chomp $err unless ref $err; $self->_cleanup_callbacks(); croak $err; } $result = $self->_auto_expand( $result ); } $self->_cleanup_callbacks(); return $result; } sub parse_xml_chunk { my $self = shift; # max 2 parameter: # 1: the chunk # 2: the encoding of the string croak("parse_xml_chunk is not a class method! Create a parser object with XML::LibXML->new first!") unless ref $self; croak("parse already in progress") if $self->{_State_}; my $result; unless ( defined $_[0] and length $_[0] ) { croak("Empty String"); } $self->{_State_} = 1; $self->_init_callbacks(); if ( defined $self->{SAX} ) { eval { $self->_parse_sax_xml_chunk( @_ ); # this is required for XML::GenericChunk. # in normal case is_filter is not defined, an thus the parsing # will be terminated. in case of a SAX filter the parsing is not # finished at that state. therefore we must not reset the parsing unless ( $self->{IS_FILTER} ) { $result = $self->{HANDLER}->end_document(); } }; } else { eval { $result = $self->_parse_xml_chunk( @_ ); }; } $self->_cleanup_callbacks(); my $err = $@; $self->{_State_} = 0; if ($err) { chomp $err unless ref $err; croak $err; } return $result; } sub parse_balanced_chunk { my $self = shift; $self->_init_callbacks(); my $rv; eval { $rv = $self->parse_xml_chunk( @_ ); }; my $err = $@; $self->_cleanup_callbacks(); if ( $err ) { chomp $err unless ref $err; croak $err; } return $rv } # java style sub processXIncludes { my $self = shift; my $doc = shift; my $opts = shift; my $options = $self->_parser_options($opts); if ( $self->{_State_} != 1 ) { $self->_init_callbacks(); } my $rv; eval { $rv = $self->_processXIncludes($doc || " ", $options); }; my $err = $@; if ( $self->{_State_} != 1 ) { $self->_cleanup_callbacks(); } if ( $err ) { chomp $err unless ref $err; croak $err; } return $rv; } # perl style sub process_xincludes { my $self = shift; my $doc = shift; my $opts = shift; my $options = $self->_parser_options($opts); my $rv; $self->_init_callbacks(); eval { $rv = $self->_processXIncludes($doc || " ", $options); }; my $err = $@; $self->_cleanup_callbacks(); if ( $err ) { chomp $err unless ref $err; croak $@; } return $rv; } #-------------------------------------------------------------------------# # HTML parsing functions # #-------------------------------------------------------------------------# sub _html_options { my ($self,$opts)=@_; $opts = {} unless ref $opts; # return (undef,undef) unless ref $opts; my $flags = 0; { my $recover = exists $opts->{recover} ? $opts->{recover} : $self->recover; if ($recover) { $flags |= HTML_PARSE_RECOVER; if ($recover == 2) { $flags |= HTML_PARSE_NOERROR; } } } $flags |= 4 if $opts->{no_defdtd}; # default is ON: injects DTD as needed $flags |= 32 if exists $opts->{suppress_errors} ? $opts->{suppress_errors} : $self->get_option('suppress_errors'); # This is to fix https://rt.cpan.org/Ticket/Display.html?id=58024 : # # In XML::LibXML, warnings are not suppressed when specifying the recover # or recover_silently flags as per the following excerpt from the manpage: # if ($self->recover_silently) { $flags |= 32; } $flags |= 64 if $opts->{suppress_warnings}; $flags |= 128 if exists $opts->{pedantic_parser} ? $opts->{pedantic_parser} : $self->pedantic_parser; $flags |= 256 if exists $opts->{no_blanks} ? $opts->{no_blanks} : !$self->keep_blanks; $flags |= 2048 if exists $opts->{no_network} ? $opts->{no_network} : !$self->no_network; $flags |= 16384 if $opts->{no_cdata}; $flags |= 65536 if $opts->{compact}; # compact small text nodes; no modification # of the tree allowed afterwards # (WILL possibly CRASH IF YOU try to MODIFY THE TREE) $flags |= 524288 if $opts->{huge}; # relax any hardcoded limit from the parser $flags |= 1048576 if $opts->{oldsax}; # parse using SAX2 interface from before 2.7.0 return ($opts->{URI},$opts->{encoding},$flags); } sub parse_html_string { my ($self,$str,$opts) = @_; croak("parse_html_string is not a class method! Create a parser object with XML::LibXML->new first!") unless ref $self; croak("parse already in progress") if $self->{_State_}; unless ( defined $str and length $str ) { croak("Empty String"); } $self->{_State_} = 1; my $result; $self->_init_callbacks(); eval { $result = $self->_parse_html_string( $str, $self->_html_options($opts) ); }; my $err = $@; $self->{_State_} = 0; if ($err) { chomp $err unless ref $err; $self->_cleanup_callbacks(); croak $err; } $self->_cleanup_callbacks(); return $result; } sub parse_html_file { my ($self,$file,$opts) = @_; croak("parse_html_file is not a class method! Create a parser object with XML::LibXML->new first!") unless ref $self; croak("parse already in progress") if $self->{_State_}; $self->{_State_} = 1; my $result; $self->_init_callbacks(); eval { $result = $self->_parse_html_file($file, $self->_html_options($opts) ); }; my $err = $@; $self->{_State_} = 0; if ($err) { chomp $err unless ref $err; $self->_cleanup_callbacks(); croak $err; } $self->_cleanup_callbacks(); return $result; } sub parse_html_fh { my ($self,$fh,$opts) = @_; croak("parse_html_fh is not a class method! Create a parser object with XML::LibXML->new first!") unless ref $self; croak("parse already in progress") if $self->{_State_}; $self->{_State_} = 1; my $result; $self->_init_callbacks(); eval { $result = $self->_parse_html_fh( $fh, $self->_html_options($opts) ); }; my $err = $@; $self->{_State_} = 0; if ($err) { chomp $err unless ref $err; $self->_cleanup_callbacks(); croak $err; } $self->_cleanup_callbacks(); return $result; } #-------------------------------------------------------------------------# # push parser interface # #-------------------------------------------------------------------------# sub init_push { my $self = shift; if ( defined $self->{CONTEXT} ) { delete $self->{CONTEXT}; } if ( defined $self->{SAX} ) { $self->{CONTEXT} = $self->_start_push(1); } else { $self->{CONTEXT} = $self->_start_push(0); } } sub push { my $self = shift; $self->_init_callbacks(); if ( not defined $self->{CONTEXT} ) { $self->init_push(); } eval { foreach ( @_ ) { $self->_push( $self->{CONTEXT}, $_ ); } }; my $err = $@; $self->_cleanup_callbacks(); if ( $err ) { chomp $err unless ref $err; croak $err; } } # this function should be promoted! # the reason is because libxml2 uses xmlParseChunk() for this purpose! sub parse_chunk { my $self = shift; my $chunk = shift; my $terminate = shift; if ( not defined $self->{CONTEXT} ) { $self->init_push(); } if ( defined $chunk and length $chunk ) { $self->_push( $self->{CONTEXT}, $chunk ); } if ( $terminate ) { return $self->finish_push(); } } sub finish_push { my $self = shift; my $restore = shift || 0; return undef unless defined $self->{CONTEXT}; my $retval; if ( defined $self->{SAX} ) { eval { $self->_end_sax_push( $self->{CONTEXT} ); $retval = $self->{HANDLER}->end_document( {} ); }; } else { eval { $retval = $self->_end_push( $self->{CONTEXT}, $restore ); }; } my $err = $@; delete $self->{CONTEXT}; if ( $err ) { chomp $err unless ref $err; croak( $err ); } return $retval; } 1; #-------------------------------------------------------------------------# # XML::LibXML::Node Interface # #-------------------------------------------------------------------------# package XML::LibXML::Node; use Carp qw(croak); use overload '""' => sub { $_[0]->toString() }, 'bool' => sub { 1 }, '0+' => sub { Scalar::Util::refaddr($_[0]) }, fallback => 1, ; sub CLONE_SKIP { return $XML::LibXML::__threads_shared ? 0 : 1; } sub isSupported { my $self = shift; my $feature = shift; return $self->can($feature) ? 1 : 0; } sub getChildNodes { my $self = shift; return $self->childNodes(); } sub childNodes { my $self = shift; my @children = $self->_childNodes(0); return wantarray ? @children : XML::LibXML::NodeList->new_from_ref(\@children , 1); } sub nonBlankChildNodes { my $self = shift; my @children = $self->_childNodes(1); return wantarray ? @children : XML::LibXML::NodeList->new_from_ref(\@children , 1); } sub attributes { my $self = shift; my @attr = $self->_attributes(); return wantarray ? @attr : XML::LibXML::NamedNodeMap->new( @attr ); } sub findnodes { my ($node, $xpath) = @_; my @nodes = $node->_findnodes($xpath); if (wantarray) { return @nodes; } else { return XML::LibXML::NodeList->new_from_ref(\@nodes, 1); } } sub exists { my ($node, $xpath) = @_; my (undef, $value) = $node->_find($xpath,1); return $value; } sub findvalue { my ($node, $xpath) = @_; my $res; $res = $node->find($xpath); return $res->to_literal->value; } sub findbool { my ($node, $xpath) = @_; my ($type, @params) = $node->_find($xpath,1); if ($type) { return $type->new(@params); } return undef; } sub find { my ($node, $xpath) = @_; my ($type, @params) = $node->_find($xpath,0); if ($type) { return $type->new(@params); } return undef; } sub setOwnerDocument { my ( $self, $doc ) = @_; $doc->adoptNode( $self ); } sub toStringC14N { my ($self, $comments, $xpath, $xpc) = @_; return $self->_toStringC14N( $comments || 0, (defined $xpath ? $xpath : undef), 0, undef, (defined $xpc ? $xpc : undef) ); } { my $C14N_version_1_dot_1_val = 2; sub toStringC14N_v1_1 { my ($self, $comments, $xpath, $xpc) = @_; return $self->_toStringC14N( $comments || 0, (defined $xpath ? $xpath : undef), $C14N_version_1_dot_1_val, undef, (defined $xpc ? $xpc : undef) ); } } sub toStringEC14N { my ($self, $comments, $xpath, $xpc, $inc_prefix_list) = @_; unless (UNIVERSAL::isa($xpc,'XML::LibXML::XPathContext')) { if ($inc_prefix_list) { croak("toStringEC14N: 3rd argument is not an XML::LibXML::XPathContext"); } else { $inc_prefix_list=$xpc; $xpc=undef; } } if (defined($inc_prefix_list) and !UNIVERSAL::isa($inc_prefix_list,'ARRAY')) { croak("toStringEC14N: inclusive_prefix_list must be undefined or ARRAY"); } return $self->_toStringC14N( $comments || 0, (defined $xpath ? $xpath : undef), 1, (defined $inc_prefix_list ? $inc_prefix_list : undef), (defined $xpc ? $xpc : undef) ); } *serialize_c14n = \&toStringC14N; *serialize_exc_c14n = \&toStringEC14N; 1; #-------------------------------------------------------------------------# # XML::LibXML::Document Interface # #-------------------------------------------------------------------------# package XML::LibXML::Document; our @ISA = ('XML::LibXML::Node'); sub actualEncoding { my $doc = shift; my $enc = $doc->encoding; return (defined $enc and length $enc) ? $enc : 'UTF-8'; } sub setDocumentElement { my $doc = shift; my $element = shift; my $oldelem = $doc->documentElement; if ( defined $oldelem ) { $doc->removeChild($oldelem); } $doc->_setDocumentElement($element); } sub toString { my $self = shift; my $flag = shift; my $retval = ""; if ( defined $XML::LibXML::skipXMLDeclaration and $XML::LibXML::skipXMLDeclaration == 1 ) { foreach ( $self->childNodes ){ next if $_->nodeType == XML::LibXML::XML_DTD_NODE() and $XML::LibXML::skipDTD; $retval .= $_->toString; } } else { $flag ||= 0 unless defined $flag; $retval = $self->_toString($flag); } return $retval; } sub serialize { my $self = shift; return $self->toString( @_ ); } #-------------------------------------------------------------------------# # bad style xinclude processing # #-------------------------------------------------------------------------# sub process_xinclude { my $self = shift; my $opts = shift; XML::LibXML->new->processXIncludes( $self, $opts ); } sub insertProcessingInstruction { my $self = shift; my $target = shift; my $data = shift; my $pi = $self->createPI( $target, $data ); my $root = $self->documentElement; if ( defined $root ) { # this is actually not correct, but i guess it's what the user # intends $self->insertBefore( $pi, $root ); } else { # if no documentElement was found we just append the PI $self->appendChild( $pi ); } } sub insertPI { my $self = shift; $self->insertProcessingInstruction( @_ ); } #-------------------------------------------------------------------------# # DOM L3 Document functions. # added after robins implicit feature request #-------------------------------------------------------------------------# *getElementsByTagName = \&XML::LibXML::Element::getElementsByTagName; *getElementsByTagNameNS = \&XML::LibXML::Element::getElementsByTagNameNS; *getElementsByLocalName = \&XML::LibXML::Element::getElementsByLocalName; 1; #-------------------------------------------------------------------------# # XML::LibXML::DocumentFragment Interface # #-------------------------------------------------------------------------# package XML::LibXML::DocumentFragment; our @ISA = ('XML::LibXML::Node'); sub toString { my $self = shift; my $retval = ""; if ( $self->hasChildNodes() ) { foreach my $n ( $self->childNodes() ) { $retval .= $n->toString(@_); } } return $retval; } *serialize = \&toString; 1; #-------------------------------------------------------------------------# # XML::LibXML::Element Interface # #-------------------------------------------------------------------------# package XML::LibXML::Element; our @ISA = ('XML::LibXML::Node'); use XML::LibXML qw(:ns :libxml); use XML::LibXML::AttributeHash; use Carp; use Scalar::Util qw(blessed); use overload '%{}' => 'getAttributeHash', 'eq' => '_isSameNodeLax', '==' => '_isSameNodeLax', 'ne' => '_isNotSameNodeLax', '!=' => '_isNotSameNodeLax', fallback => 1, ; sub _isNotSameNodeLax { my ($self, $other) = @_; return ((not $self->_isSameNodeLax($other)) ? 1 : ''); } sub _isSameNodeLax { my ($self, $other) = @_; if (blessed($other) and $other->isa('XML::LibXML::Element')) { return ($self->isSameNode($other) ? 1 : ''); } else { return ''; } } { my %tiecache; sub __destroy_tiecache { delete $tiecache{ 0+$_[0] }; } sub getAttributeHash { my $self = shift; if (!exists $tiecache{ 0+$self }) { tie my %attr, 'XML::LibXML::AttributeHash', $self, weaken => 1; $tiecache{ 0+$self } = \%attr; } return $tiecache{ 0+$self }; } sub DESTROY { my ($self) = @_; $self->__destroy_tiecache; $self->SUPER::DESTROY; } } sub setNamespace { my $self = shift; my $n = $self->localname; if ( $self->_setNamespace(@_) ){ if ( scalar @_ < 3 || $_[2] == 1 ){ $self->setNodeName( $n ); } return 1; } return 0; } sub getAttribute { my $self = shift; my $name = $_[0]; if ( $name =~ /^xmlns(?::|$)/ ) { # user wants to get a namespace ... (my $prefix = $name )=~s/^xmlns:?//; $self->_getNamespaceDeclURI($prefix); } else { $self->_getAttribute(@_); } } sub setAttribute { my ( $self, $name, $value ) = @_; if ( $name =~ /^xmlns(?::|$)/ ) { # user wants to set the special attribute for declaring XML namespace ... # this is fine but not exactly DOM conformant behavior, btw (according to DOM we should # probably declare an attribute which looks like XML namespace declaration # but isn't) (my $nsprefix = $name )=~s/^xmlns:?//; my $nn = $self->nodeName; if ( $nn =~ /^\Q${nsprefix}\E:/ ) { # the element has the same prefix $self->setNamespaceDeclURI($nsprefix,$value) || $self->setNamespace($value,$nsprefix,1); ## ## We set the namespace here. ## This is helpful, as in: ## ## | $e = XML::LibXML::Element->new('foo:bar'); ## | $e->setAttribute('xmlns:foo','http://yoyodine') ## } else { # just modify the namespace $self->setNamespaceDeclURI($nsprefix, $value) || $self->setNamespace($value,$nsprefix,0); } } else { $self->_setAttribute($name, $value); } } sub getAttributeNS { my $self = shift; my ($nsURI, $name) = @_; croak("invalid attribute name") if !defined($name) or $name eq q{}; if ( defined($nsURI) and $nsURI eq XML_XMLNS_NS ) { $self->_getNamespaceDeclURI($name eq 'xmlns' ? undef : $name); } else { $self->_getAttributeNS(@_); } } sub setAttributeNS { my ($self, $nsURI, $qname, $value)=@_; unless (defined $qname and length $qname) { croak("bad name"); } if (defined($nsURI) and $nsURI eq XML_XMLNS_NS) { if ($qname !~ /^xmlns(?::|$)/) { croak("NAMESPACE ERROR: Namespace declarations must have the prefix 'xmlns'"); } $self->setAttribute($qname,$value); # see implementation above return; } if ($qname=~/:/ and not (defined($nsURI) and length($nsURI))) { croak("NAMESPACE ERROR: Attribute without a prefix cannot be in a namespace"); } if ($qname=~/^xmlns(?:$|:)/) { croak("NAMESPACE ERROR: 'xmlns' prefix and qualified-name are reserved for the namespace ".XML_XMLNS_NS); } if ($qname=~/^xml:/ and not (defined $nsURI and $nsURI eq XML_XML_NS)) { croak("NAMESPACE ERROR: 'xml' prefix is reserved for the namespace ".XML_XML_NS); } $self->_setAttributeNS( defined $nsURI ? $nsURI : undef, $qname, $value ); } sub getElementsByTagName { my ( $node , $name ) = @_; my $xpath = $name eq '*' ? "descendant::*" : "descendant::*[name()='$name']"; my @nodes = $node->_findnodes($xpath); return wantarray ? @nodes : XML::LibXML::NodeList->new_from_ref(\@nodes, 1); } sub getElementsByTagNameNS { my ( $node, $nsURI, $name ) = @_; my $xpath; if ( $name eq '*' ) { if ( $nsURI eq '*' ) { $xpath = "descendant::*"; } else { $xpath = "descendant::*[namespace-uri()='$nsURI']"; } } elsif ( $nsURI eq '*' ) { $xpath = "descendant::*[local-name()='$name']"; } else { $xpath = "descendant::*[local-name()='$name' and namespace-uri()='$nsURI']"; } my @nodes = $node->_findnodes($xpath); return wantarray ? @nodes : XML::LibXML::NodeList->new_from_ref(\@nodes, 1); } sub getElementsByLocalName { my ( $node,$name ) = @_; my $xpath; if ($name eq '*') { $xpath = "descendant::*"; } else { $xpath = "descendant::*[local-name()='$name']"; } my @nodes = $node->_findnodes($xpath); return wantarray ? @nodes : XML::LibXML::NodeList->new_from_ref(\@nodes, 1); } sub getChildrenByTagName { my ( $node, $name ) = @_; my @nodes; if ($name eq '*') { @nodes = grep { $_->nodeType == XML_ELEMENT_NODE() } $node->childNodes(); } else { @nodes = grep { $_->nodeName eq $name } $node->childNodes(); } return wantarray ? @nodes : XML::LibXML::NodeList->new_from_ref(\@nodes, 1); } sub getChildrenByLocalName { my ( $node, $name ) = @_; # my @nodes; # if ($name eq '*') { # @nodes = grep { $_->nodeType == XML_ELEMENT_NODE() } # $node->childNodes(); # } else { # @nodes = grep { $_->nodeType == XML_ELEMENT_NODE() and # $_->localName eq $name } $node->childNodes(); # } # return wantarray ? @nodes : XML::LibXML::NodeList->new_from_ref(\@nodes, 1); my @nodes = $node->_getChildrenByTagNameNS('*',$name); return wantarray ? @nodes : XML::LibXML::NodeList->new_from_ref(\@nodes, 1); } sub getChildrenByTagNameNS { my ( $node, $nsURI, $name ) = @_; my @nodes = $node->_getChildrenByTagNameNS($nsURI,$name); return wantarray ? @nodes : XML::LibXML::NodeList->new_from_ref(\@nodes, 1); } sub appendWellBalancedChunk { my ( $self, $chunk ) = @_; my $local_parser = XML::LibXML->new(); my $frag = $local_parser->parse_xml_chunk( $chunk ); $self->appendChild( $frag ); } 1; #-------------------------------------------------------------------------# # XML::LibXML::Text Interface # #-------------------------------------------------------------------------# package XML::LibXML::Text; our @ISA = ('XML::LibXML::Node'); sub attributes { return; } sub deleteDataString { my ($node, $string, $all) = @_; return $node->replaceDataString($string, '', $all); } sub replaceDataString { my ( $node, $left_proto, $right,$all ) = @_; # Assure we exchange the strings and not expressions! my $left = quotemeta($left_proto); my $datastr = $node->nodeValue(); if ( $all ) { $datastr =~ s/$left/$right/g; } else{ $datastr =~ s/$left/$right/; } $node->setData( $datastr ); } sub replaceDataRegEx { my ( $node, $leftre, $rightre, $flags ) = @_; return unless defined $leftre; $rightre ||= ""; my $datastr = $node->nodeValue(); my $restr = "s/" . $leftre . "/" . $rightre . "/"; $restr .= $flags if defined $flags; eval '$datastr =~ '. $restr; $node->setData( $datastr ); } 1; package XML::LibXML::Comment; our @ISA = ('XML::LibXML::Text'); 1; package XML::LibXML::CDATASection; our @ISA = ('XML::LibXML::Text'); 1; #-------------------------------------------------------------------------# # XML::LibXML::Attribute Interface # #-------------------------------------------------------------------------# package XML::LibXML::Attr; our @ISA = ('XML::LibXML::Node') ; sub setNamespace { my ($self,$href,$prefix) = @_; my $n = $self->localname; if ( $self->_setNamespace($href,$prefix) ) { $self->setNodeName($n); return 1; } return 0; } 1; #-------------------------------------------------------------------------# # XML::LibXML::Dtd Interface # #-------------------------------------------------------------------------# # this is still under construction # package XML::LibXML::Dtd; our @ISA = ('XML::LibXML::Node'); # at least DESTROY and CLONE_SKIP must be inherited 1; #-------------------------------------------------------------------------# # XML::LibXML::PI Interface # #-------------------------------------------------------------------------# package XML::LibXML::PI; our @ISA = ('XML::LibXML::Node'); sub setData { my $pi = shift; my $string = ""; if ( scalar @_ == 1 ) { $string = shift; } else { my %h = @_; $string = join " ", map {$_.'="'.$h{$_}.'"'} keys %h; } # the spec says any char but "?>" [17] $pi->_setData( $string ) unless $string =~ /\?>/; } 1; #-------------------------------------------------------------------------# # XML::LibXML::Namespace Interface # #-------------------------------------------------------------------------# package XML::LibXML::Namespace; sub CLONE_SKIP { 1 } # In fact, this is not a node! sub prefix { return "xmlns"; } sub getPrefix { return "xmlns"; } sub getNamespaceURI { return "http://www.w3.org/2000/xmlns/" }; sub getNamespaces { return (); } sub nodeName { my $self = shift; my $nsP = $self->localname; return ( defined($nsP) && length($nsP) ) ? "xmlns:$nsP" : "xmlns"; } sub name { goto &nodeName } sub getName { goto &nodeName } sub isEqualNode { my ( $self, $ref ) = @_; if ( ref($ref) eq "XML::LibXML::Namespace" ) { return $self->_isEqual($ref); } return 0; } sub isSameNode { my ( $self, $ref ) = @_; if ( $$self == $$ref ){ return 1; } return 0; } 1; #-------------------------------------------------------------------------# # XML::LibXML::NamedNodeMap Interface # #-------------------------------------------------------------------------# package XML::LibXML::NamedNodeMap; use XML::LibXML qw(:libxml); sub CLONE_SKIP { return $XML::LibXML::__threads_shared ? 0 : 1; } sub new { my $class = shift; my $self = bless { Nodes => [@_] }, $class; $self->{NodeMap} = { map { $_->nodeName => $_ } @_ }; return $self; } sub length { return scalar( @{$_[0]->{Nodes}} ); } sub nodes { return $_[0]->{Nodes}; } sub item { $_[0]->{Nodes}->[$_[1]]; } sub getNamedItem { my $self = shift; my $name = shift; return $self->{NodeMap}->{$name}; } sub setNamedItem { my $self = shift; my $node = shift; my $retval; if ( defined $node ) { if ( scalar @{$self->{Nodes}} ) { my $name = $node->nodeName(); if ( $node->nodeType() == XML_NAMESPACE_DECL ) { return; } if ( defined $self->{NodeMap}->{$name} ) { if ( $node->isSameNode( $self->{NodeMap}->{$name} ) ) { return; } $retval = $self->{NodeMap}->{$name}->replaceNode( $node ); } else { $self->{Nodes}->[0]->addSibling($node); } $self->{NodeMap}->{$name} = $node; push @{$self->{Nodes}}, $node; } else { # not done yet # can this be properly be done??? warn "not done yet\n"; } } return $retval; } sub removeNamedItem { my $self = shift; my $name = shift; my $retval; if ( $name =~ /^xmlns/ ) { warn "not done yet\n"; } elsif ( exists $self->{NodeMap}->{$name} ) { $retval = $self->{NodeMap}->{$name}; $retval->unbindNode; delete $self->{NodeMap}->{$name}; $self->{Nodes} = [grep {not($retval->isSameNode($_))} @{$self->{Nodes}}]; } return $retval; } sub getNamedItemNS { my $self = shift; my $nsURI = shift; my $name = shift; return undef; } sub setNamedItemNS { my $self = shift; my $nsURI = shift; my $node = shift; return undef; } sub removeNamedItemNS { my $self = shift; my $nsURI = shift; my $name = shift; return undef; } 1; package XML::LibXML::_SAXParser; # this is pseudo class!!! and it will be removed as soon all functions # moved to XS level use XML::SAX::Exception; sub CLONE_SKIP { return $XML::LibXML::__threads_shared ? 0 : 1; } # these functions will use SAX exceptions as soon i know how things really work sub warning { my ( $parser, $message, $line, $col ) = @_; my $error = XML::SAX::Exception::Parse->new( LineNumber => $line, ColumnNumber => $col, Message => $message, ); $parser->{HANDLER}->warning( $error ); } sub error { my ( $parser, $message, $line, $col ) = @_; my $error = XML::SAX::Exception::Parse->new( LineNumber => $line, ColumnNumber => $col, Message => $message, ); $parser->{HANDLER}->error( $error ); } sub fatal_error { my ( $parser, $message, $line, $col ) = @_; my $error = XML::SAX::Exception::Parse->new( LineNumber => $line, ColumnNumber => $col, Message => $message, ); $parser->{HANDLER}->fatal_error( $error ); } 1; package XML::LibXML::RelaxNG; sub CLONE_SKIP { 1 } sub new { my $class = shift; my %args = @_; my $self = undef; if ( defined $args{location} ) { $self = $class->parse_location( $args{location}, XML::LibXML->_parser_options(\%args), $args{recover} ); } elsif ( defined $args{string} ) { $self = $class->parse_buffer( $args{string}, XML::LibXML->_parser_options(\%args), $args{recover} ); } elsif ( defined $args{DOM} ) { $self = $class->parse_document( $args{DOM}, XML::LibXML->_parser_options(\%args), $args{recover} ); } return $self; } 1; package XML::LibXML::Schema; sub CLONE_SKIP { 1 } sub new { my $class = shift; my %args = @_; my $self = undef; if ( defined $args{location} ) { $self = $class->parse_location( $args{location}, XML::LibXML->_parser_options(\%args), $args{recover} ); } elsif ( defined $args{string} ) { $self = $class->parse_buffer( $args{string}, XML::LibXML->_parser_options(\%args), $args{recover} ); } return $self; } 1; #-------------------------------------------------------------------------# # XML::LibXML::Pattern Interface # #-------------------------------------------------------------------------# package XML::LibXML::Pattern; sub CLONE_SKIP { 1 } sub new { my $class = shift; my ($pattern,$ns_map)=@_; my $self = undef; unless (UNIVERSAL::can($class,'_compilePattern')) { croak("Cannot create XML::LibXML::Pattern - ". "your libxml2 is compiled without pattern support!"); } if (ref($ns_map) eq 'HASH') { # translate prefix=>URL hash to a (URL,prefix) list $self = $class->_compilePattern($pattern,0,[reverse %$ns_map]); } else { $self = $class->_compilePattern($pattern,0); } return $self; } 1; #-------------------------------------------------------------------------# # XML::LibXML::RegExp Interface # #-------------------------------------------------------------------------# package XML::LibXML::RegExp; sub CLONE_SKIP { 1 } sub new { my $class = shift; my ($regexp)=@_; unless (UNIVERSAL::can($class,'_compile')) { croak("Cannot create XML::LibXML::RegExp - ". "your libxml2 is compiled without regexp support!"); } return $class->_compile($regexp); } 1; #-------------------------------------------------------------------------# # XML::LibXML::XPathExpression Interface # #-------------------------------------------------------------------------# package XML::LibXML::XPathExpression; sub CLONE_SKIP { 1 } 1; #-------------------------------------------------------------------------# # XML::LibXML::InputCallback Interface # #-------------------------------------------------------------------------# package XML::LibXML::InputCallback; our ($_CUR_CB, @_GLOBAL_CALLBACKS, @_CB_STACK, $_CB_NESTED_DEPTH, @_CB_NESTED_STACK); BEGIN { $_CUR_CB = undef; @_GLOBAL_CALLBACKS = (); @_CB_STACK = (); $_CB_NESTED_DEPTH = 0; @_CB_NESTED_STACK = (); } sub CLONE_SKIP { return $XML::LibXML::__threads_shared ? 0 : 1; } #-------------------------------------------------------------------------# # global callbacks # #-------------------------------------------------------------------------# sub _callback_match { my $uri = shift; my $retval = 0; # loop through the callbacks, and find the first matching one. # The callbacks are stored in execution order (reverse stack order). # Any new global callbacks are shifted to the callback stack. foreach my $cb ( @_GLOBAL_CALLBACKS ) { # callbacks have to return 1, 0 or undef, while 0 and undef # are handled the same way. # in fact, if callbacks return other values, the global match # assumes silently that the callback failed. $retval = $cb->[0]->($uri); if ( defined $retval and $retval == 1 ) { # make the other callbacks use this callback $_CUR_CB = $cb; unshift @_CB_STACK, $cb; last; } } return $retval; } sub _callback_open { my $uri = shift; my $retval = undef; # the open callback has to return a defined value. # if one works on files this can be a file handle. But # depending on the needs of the callback it also can be a # database handle or a integer labeling a certain dataset. if ( defined $_CUR_CB ) { $retval = $_CUR_CB->[1]->( $uri ); # reset the callbacks, if one callback cannot open an uri if ( not defined $retval or $retval == 0 ) { shift @_CB_STACK; $_CUR_CB = $_CB_STACK[0]; } } return $retval; } sub _callback_read { my $fh = shift; my $buflen = shift; my $retval = undef; if ( defined $_CUR_CB ) { $retval = $_CUR_CB->[2]->( $fh, $buflen ); } return $retval; } sub _callback_close { my $fh = shift; my $retval = 0; if ( defined $_CUR_CB ) { $retval = $_CUR_CB->[3]->( $fh ); shift @_CB_STACK; $_CUR_CB = $_CB_STACK[0]; } return $retval; } #-------------------------------------------------------------------------# # member functions and methods # #-------------------------------------------------------------------------# sub new { my $CLASS = shift; return bless {'_CALLBACKS' => []}, $CLASS; } # add a callback set to the callback stack # synopsis: $icb->register_callbacks( [$match_cb, $open_cb, $read_cb, $close_cb] ); sub register_callbacks { my $self = shift; my $cbset = shift; # test if callback set is complete if ( ref $cbset eq "ARRAY" and scalar( @$cbset ) == 4 ) { unshift @{$self->{_CALLBACKS}}, $cbset; } } # remove a callback set to the callback stack # if a callback set is passed, this function will check for the match function sub unregister_callbacks { my $self = shift; my $cbset = shift; if ( ref $cbset eq "ARRAY" and scalar( @$cbset ) == 4 ) { $self->{_CALLBACKS} = [grep { $_->[0] != $cbset->[0] } @{$self->{_CALLBACKS}}]; } else { shift @{$self->{_CALLBACKS}}; } } # make libxml2 use the callbacks sub init_callbacks { my $self = shift; my $parser = shift; #initialize the libxml2 callbacks unless this is a nested callback $self->lib_init_callbacks() unless($_CB_NESTED_DEPTH); #store the callbacks for any outer executing parser instance $_CB_NESTED_DEPTH++; push @_CB_NESTED_STACK, [ $_CUR_CB, [@_CB_STACK], [@_GLOBAL_CALLBACKS], ]; #initialize the callback variables for the current parser $_CUR_CB = undef; @_CB_STACK = (); @_GLOBAL_CALLBACKS = @{ $self->{_CALLBACKS} }; #attach parser specific callbacks if($parser) { my $mcb = $parser->match_callback(); my $ocb = $parser->open_callback(); my $rcb = $parser->read_callback(); my $ccb = $parser->close_callback(); if ( defined $mcb and defined $ocb and defined $rcb and defined $ccb ) { unshift @_GLOBAL_CALLBACKS, [$mcb, $ocb, $rcb, $ccb]; } } #attach global callbacks if ( defined $XML::LibXML::match_cb and defined $XML::LibXML::open_cb and defined $XML::LibXML::read_cb and defined $XML::LibXML::close_cb ) { push @_GLOBAL_CALLBACKS, [$XML::LibXML::match_cb, $XML::LibXML::open_cb, $XML::LibXML::read_cb, $XML::LibXML::close_cb]; } } # reset libxml2's callbacks sub cleanup_callbacks { my $self = shift; #restore the callbacks for the outer parser instance $_CB_NESTED_DEPTH--; my $saved = pop @_CB_NESTED_STACK; $_CUR_CB = $saved->[0]; @_CB_STACK = (@{$saved->[1]}); @_GLOBAL_CALLBACKS = (@{$saved->[2]}); #clean up the libxml2 callbacks unless there are still outer parsing instances $self->lib_cleanup_callbacks() unless($_CB_NESTED_DEPTH); } $__loaded=1; 1; __END__ PKM]X/IlIl Parser.pmnu6$# XML::Parser # # Copyright (c) 1998-2000 Larry Wall and Clark Cooper # All rights reserved. # # This program is free software; you can redistribute it and/or # modify it under the same terms as Perl itself. package XML::Parser; use strict; our ( $VERSION, $LWP_load_failed ); use Carp; BEGIN { require XML::Parser::Expat; $VERSION = '2.46'; die "Parser.pm and Expat.pm versions don't match" unless $VERSION eq $XML::Parser::Expat::VERSION; } $LWP_load_failed = 0; sub new { my ( $class, %args ) = @_; my $style = $args{Style}; my $nonexopt = $args{Non_Expat_Options} ||= {}; $nonexopt->{Style} = 1; $nonexopt->{Non_Expat_Options} = 1; $nonexopt->{Handlers} = 1; $nonexopt->{_HNDL_TYPES} = 1; $nonexopt->{NoLWP} = 1; $args{_HNDL_TYPES} = {%XML::Parser::Expat::Handler_Setters}; $args{_HNDL_TYPES}->{Init} = 1; $args{_HNDL_TYPES}->{Final} = 1; $args{Handlers} ||= {}; my $handlers = $args{Handlers}; if ( defined($style) ) { my $stylepkg = $style; if ( $stylepkg !~ /::/ ) { $stylepkg = "\u$style"; eval { my $fullpkg = "XML::Parser::Style::$stylepkg"; my $stylefile = $fullpkg; $stylefile =~ s/::/\//g; require "$stylefile.pm"; $stylepkg = $fullpkg; }; if ($@) { # fallback to old behaviour $stylepkg = "XML::Parser::$stylepkg"; } } foreach my $htype ( keys %{ $args{_HNDL_TYPES} } ) { # Handlers explicitly given override # handlers from the Style package unless ( defined( $handlers->{$htype} ) ) { # A handler in the style package must either have # exactly the right case as the type name or a # completely lower case version of it. my $hname = "${stylepkg}::$htype"; if ( defined(&$hname) ) { $handlers->{$htype} = \&$hname; next; } $hname = "${stylepkg}::\L$htype"; if ( defined(&$hname) ) { $handlers->{$htype} = \&$hname; next; } } } } unless ( defined( $handlers->{ExternEnt} ) or defined( $handlers->{ExternEntFin} ) ) { if ( $args{NoLWP} or $LWP_load_failed ) { $handlers->{ExternEnt} = \&file_ext_ent_handler; $handlers->{ExternEntFin} = \&file_ext_ent_cleanup; } else { # The following just bootstraps the real LWP external entity # handler $handlers->{ExternEnt} = \&initial_ext_ent_handler; # No cleanup function available until LWPExternEnt.pl loaded } } $args{Pkg} ||= caller; bless \%args, $class; } # End of new sub setHandlers { my ( $self, @handler_pairs ) = @_; croak('Uneven number of arguments to setHandlers method') if ( int(@handler_pairs) & 1 ); my @ret; while (@handler_pairs) { my $type = shift @handler_pairs; my $handler = shift @handler_pairs; unless ( defined( $self->{_HNDL_TYPES}->{$type} ) ) { my @types = sort keys %{ $self->{_HNDL_TYPES} }; croak("Unknown Parser handler type: $type\n Valid types: @types"); } push( @ret, $type, $self->{Handlers}->{$type} ); $self->{Handlers}->{$type} = $handler; } return @ret; } sub parse_start { my $self = shift; my @expat_options = (); my ( $key, $val ); while ( ( $key, $val ) = each %{$self} ) { push( @expat_options, $key, $val ) unless exists $self->{Non_Expat_Options}->{$key}; } my %handlers = %{ $self->{Handlers} }; my $init = delete $handlers{Init}; my $final = delete $handlers{Final}; my $expatnb = XML::Parser::ExpatNB->new( @expat_options, @_ ); $expatnb->setHandlers(%handlers); &$init($expatnb) if defined($init); $expatnb->{_State_} = 1; $expatnb->{FinalHandler} = $final if defined($final); return $expatnb; } sub parse { my $self = shift; my $arg = shift; my @expat_options = (); my ( $key, $val ); while ( ( $key, $val ) = each %{$self} ) { push( @expat_options, $key, $val ) unless exists $self->{Non_Expat_Options}->{$key}; } my $expat = XML::Parser::Expat->new( @expat_options, @_ ); my %handlers = %{ $self->{Handlers} }; my $init = delete $handlers{Init}; my $final = delete $handlers{Final}; $expat->setHandlers(%handlers); if ( $self->{Base} ) { $expat->base( $self->{Base} ); } &$init($expat) if defined($init); my @result = (); my $result; eval { $result = $expat->parse($arg); }; my $err = $@; if ($err) { $expat->release; die $err; } if ( $result and defined($final) ) { if (wantarray) { @result = &$final($expat); } else { $result = &$final($expat); } } $expat->release; return unless defined wantarray; return wantarray ? @result : $result; } sub parsestring { my $self = shift; $self->parse(@_); } sub parsefile { my $self = shift; my $file = shift; open( my $fh, '<', $file ) or croak "Couldn't open $file:\n$!"; binmode($fh); my @ret; my $ret; $self->{Base} = $file; if (wantarray) { eval { @ret = $self->parse( $fh, @_ ); }; } else { eval { $ret = $self->parse( $fh, @_ ); }; } my $err = $@; close($fh); die $err if $err; return unless defined wantarray; return wantarray ? @ret : $ret; } sub initial_ext_ent_handler { # This just bootstraps in the real lwp_ext_ent_handler which # also loads the URI and LWP modules. unless ($LWP_load_failed) { local ($^W) = 0; my $stat = eval { require('XML/Parser/LWPExternEnt.pl'); }; if ($stat) { $_[0]->setHandlers( ExternEnt => \&lwp_ext_ent_handler, ExternEntFin => \&lwp_ext_ent_cleanup ); goto &lwp_ext_ent_handler; } # Failed to load lwp handler, act as if NoLWP $LWP_load_failed = 1; my $cmsg = "Couldn't load LWP based external entity handler\n" . "Switching to file-based external entity handler\n" . " (To avoid this message, use NoLWP option to XML::Parser)\n"; warn($cmsg); } $_[0]->setHandlers( ExternEnt => \&file_ext_ent_handler, ExternEntFin => \&file_ext_ent_cleanup ); goto &file_ext_ent_handler; } sub file_ext_ent_handler { my ( $xp, $base, $path ) = @_; # Prepend base only for relative paths if ( defined($base) and not( $path =~ m!^(?:[\\/]|\w+:)! ) ) { my $newpath = $base; $newpath =~ s![^\\/:]*$!$path!; $path = $newpath; } if ( $path =~ /^\s*[|>+]/ or $path =~ /\|\s*$/ ) { $xp->{ErrorMessage} .= "System ID ($path) contains Perl IO control characters"; return undef; } require IO::File; my $fh = IO::File->new($path); unless ( defined $fh ) { $xp->{ErrorMessage} .= "Failed to open $path:\n$!"; return undef; } $xp->{_BaseStack} ||= []; $xp->{_FhStack} ||= []; push( @{ $xp->{_BaseStack} }, $base ); push( @{ $xp->{_FhStack} }, $fh ); $xp->base($path); return $fh; } sub file_ext_ent_cleanup { my ($xp) = @_; my $fh = pop( @{ $xp->{_FhStack} } ); $fh->close; my $base = pop( @{ $xp->{_BaseStack} } ); $xp->base($base); } 1; __END__ =head1 NAME XML::Parser - A perl module for parsing XML documents =head1 SYNOPSIS use XML::Parser; $p1 = XML::Parser->new(Style => 'Debug'); $p1->parsefile('REC-xml-19980210.xml'); $p1->parse('Hello World'); # Alternative $p2 = XML::Parser->new(Handlers => {Start => \&handle_start, End => \&handle_end, Char => \&handle_char}); $p2->parse($socket); # Another alternative $p3 = XML::Parser->new(ErrorContext => 2); $p3->setHandlers(Char => \&text, Default => \&other); open(my $fh, 'xmlgenerator |'); $p3->parse($foo, ProtocolEncoding => 'ISO-8859-1'); close($foo); $p3->parsefile('junk.xml', ErrorContext => 3); =begin man .ds PI =end man =head1 DESCRIPTION This module provides ways to parse XML documents. It is built on top of L, 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 C> and/or C> options, or by L method. These all provide mechanisms for XML::Parser to set the handlers needed by XML::Parser::Expat. If neither C