diff options
Diffstat (limited to 'Master/tlpkg/tlperl.straw/lib/XML/LibXML')
39 files changed, 8628 insertions, 0 deletions
diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Attr.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Attr.pod new file mode 100755 index 00000000000..eeb2678ecb6 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Attr.pod @@ -0,0 +1,134 @@ +=head1 NAME + +XML::LibXML::Attr - XML::LibXML Attribute Class + +=head1 SYNOPSIS + + + + use XML::LibXML; + # Only methods specific to Attribute nodes are listed here, + # see 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<<<<<< createAttrbute >>>>>> 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 + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Boolean.pm b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Boolean.pm new file mode 100755 index 00000000000..03db16788e7 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Boolean.pm @@ -0,0 +1,92 @@ +# $Id: Boolean.pm 785 2009-07-16 14:17:46Z 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::Boolean; +use XML::LibXML::Number; +use XML::LibXML::Literal; +use strict; + +use vars qw ($VERSION); + +$VERSION = "1.70"; # 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 diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/CDATASection.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/CDATASection.pod new file mode 100755 index 00000000000..c1f1b0996c3 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/CDATASection.pod @@ -0,0 +1,58 @@ +=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 XML::LibXML::Node manpage for other methods + + $node = XML::LibXML::CDATASection( $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( $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 + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Comment.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Comment.pod new file mode 100755 index 00000000000..f5e0829af01 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Comment.pod @@ -0,0 +1,59 @@ +=head1 NAME + +XML::LibXML::Comment - XML::LibXML Comment Class + +=head1 SYNOPSIS + + + + use XML::LibXML; + # Only methods specific to Comment nodes are listed here, + # see XML::LibXML::Node manpage for other methods + + $node = XML::LibXML::Comment( $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( $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 + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Common.pm b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Common.pm new file mode 100755 index 00000000000..2050c8af363 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Common.pm @@ -0,0 +1,203 @@ +#-------------------------------------------------------------------------# +# $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; + +require Exporter; +require DynaLoader; +use vars qw( @ISA $VERSION @EXPORT @EXPORT_OK %EXPORT_TAGS); + +@ISA = qw(Exporter); + +$VERSION = "1.70"; # VERSION TEMPLATE: DO NOT CHANGE + +use XML::LibXML qw(:libxml); + +#-------------------------------------------------------------------------# +# export information # +#-------------------------------------------------------------------------# +%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 + )], + ); + +@EXPORT_OK = ( + @{$EXPORT_TAGS{encoding}}, + @{$EXPORT_TAGS{w3c}}, + @{$EXPORT_TAGS{libxml}}, + @{$EXPORT_TAGS{gdome}}, + ); + +@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__ + diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Common.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Common.pod new file mode 100755 index 00000000000..6097399b7e2 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Common.pod @@ -0,0 +1,129 @@ +=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 interfact 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 funcions 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 +occours 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 misterious 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 + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/DOM.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/DOM.pod new file mode 100755 index 00000000000..27fd92c6d59 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/DOM.pod @@ -0,0 +1,142 @@ +=head1 NAME + +XML::LibXML::DOM - XML::LibXML DOM Implementation + +=head1 DESCRIPTION + +XML::LibXML provides an light-wight 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. Additionally to the +specified functions the 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 different than a perl hash or array. The only way to +access these structure's values is through the DOM interface provided by +XML::LibXML. This also means, that one I<<<<<< can't >>>>>> simply inherit a XML::LibXML node and add new member variables as 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 do 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 +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. + +Also 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 +apropriate 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: + + + + <?xml version="1.0"?> + <foo xmlns:bar="bar" bar:foo="test"/> + +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 + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Document.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Document.pod new file mode 100755 index 00000000000..a4769d992db --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Document.pod @@ -0,0 +1,696 @@ +=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 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 [, $xpath_context ]); + $ec14nstr = $doc->toStringEC14N($comment_flag, $xpath [, $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, $qname ); + $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->create( $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: + + + + <?xml version="your version" encoding="your encoding"?> + +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: + + + + <?xml version="1.0"?> + +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 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 a 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 OUT, $file; + print OUT $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 [, $xpath_context ]); + +See the documentation in L<<<<<< XML::LibXML::Node >>>>>>. + + +=item toStringEC14N + + $ec14nstr = $doc->toStringEC14N($comment_flag, $xpath [, $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. + + +=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, $qname ); + +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->create( $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: + + + + <?xml version="1.0"?> + <!DOCTYPE foo SYSTEM "foo.dtd"> + +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: + + + + <?xml version="1.0"?> + <!DOCTYPE foo PUBLIC "-//FOO//DTD FOO 0.1//EN"> + + +=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->cloneNode(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 a 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 a 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 a 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 + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/DocumentFragment.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/DocumentFragment.pod new file mode 100755 index 00000000000..fb21235c117 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/DocumentFragment.pod @@ -0,0 +1,40 @@ +=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 + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Dtd.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Dtd.pod new file mode 100755 index 00000000000..d0b29904c23 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Dtd.pod @@ -0,0 +1,102 @@ +=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 + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Element.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Element.pod new file mode 100755 index 00000000000..b938c25d78c --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Element.pod @@ -0,0 +1,384 @@ +=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 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->setAttributeNS( $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->setAttributeNS( $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 a 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 a 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 a 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_xml_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 + + + + <foo:bar xmlns:foo="http://foobar.org"/> + +while + + + + my $e2 = $doc->createElement("bar"); + $e2->setNamespace("http://foobar.org", "foo",0) + +results only + + + + <bar xmlns:foo="http://foobar.org"/> + +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 AUTHORS + +Matt Sergeant, +Christian Glahn, +Petr Pajas + + +=head1 VERSION + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/ErrNo.pm b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/ErrNo.pm new file mode 100755 index 00000000000..0e120ab8abe --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/ErrNo.pm @@ -0,0 +1,500 @@ +# $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 vars qw($VERSION); + +$VERSION = "1.70"; # 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; diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/ErrNo.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/ErrNo.pod new file mode 100755 index 00000000000..39b5cf432c3 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/ErrNo.pod @@ -0,0 +1,27 @@ +=head1 NAME + +XML::LibXML::ErrNo - Structured Errors +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 + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Error.pm b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Error.pm new file mode 100755 index 00000000000..b60d6cf2e9e --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Error.pm @@ -0,0 +1,229 @@ +# $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 vars qw($AUTOLOAD @error_domains $VERSION $WARNINGS); +use Carp; +use overload + '""' => \&as_string, + 'eq' => sub { + ("$_[0]" eq "$_[1]") + }, + 'cmp' => sub { + ("$_[0]" cmp "$_[1]") + }, + fallback => 1; + +$WARNINGS = 0; # 0: supress, 1: report via warn, 2: report via die +$VERSION = "1.70"; # 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 validaton module + +@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"); + +{ + + 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(), + (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, + }, $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; + $terr->{_prev} = ref($prev) ? $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; + } + } +} + + +sub AUTOLOAD { + my $self=shift; + return undef unless ref($self); + my $sub = $AUTOLOAD; + $sub =~ s/.*:://; + if ($sub=~/^(?:code|_prev|level|file|line|domain|nodename|message|column|context|str[123]|num[12])$/) { + return $self->{$sub}; + } else { + croak("Unknown error field $sub"); + } +} + +# backward compatibility +sub int1 { $_[0]->num1 } +sub int2 { $_[0]->num2 } + +sub DESTROY {} + +sub domain { + my ($self)=@_; + return undef unless ref($self); + return $error_domains[$self->{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.=$error_domains[$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}) { + my $context = $self->{context}; + $msg.=$context."\n"; + $context = substr($context,0,$self->{column}); + $context=~s/[^\t]/ /g; + $msg.=$context."^\n"; + } + return $msg; +} + +sub dump { + my ($self)=@_; + use Data::Dumper; + return Data::Dumper->new([$self],['error'])->Dump; +} + +1; diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Error.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Error.pod new file mode 100755 index 00000000000..9583ba5b76f --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Error.pod @@ -0,0 +1,254 @@ +=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 compied 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 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 supressing 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 >>>>>>. + + $message = $@->as_string(); + +This functions takes serializes a 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 a 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<<<<<< $@->column() >>>>>> contains the corresponding offset. Where N/A, the field is undefined. + + +=item column + + $offset = $@->column(); + +See C<<<<<< $@->column() >>>>>> 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 + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/InputCallback.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/InputCallback.pod new file mode 100755 index 00000000000..d3766162629 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/InputCallback.pod @@ -0,0 +1,292 @@ +=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 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 work on a 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 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() + +Initializes the callback system before 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 + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Literal.pm b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Literal.pm new file mode 100755 index 00000000000..d3b34ec2f81 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Literal.pm @@ -0,0 +1,109 @@ +# $Id: Literal.pm 785 2009-07-16 14:17:46Z 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::Literal; +use XML::LibXML::Boolean; +use XML::LibXML::Number; +use strict; + +use vars qw ($VERSION); +$VERSION = "1.70"; # 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 "<Literal>$string</Literal>\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: + + <xsl:value-of select=""I'm feeling &quot;sad&quot;""/> + +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 diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Namespace.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Namespace.pod new file mode 100755 index 00000000000..f8fca958d99 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Namespace.pod @@ -0,0 +1,143 @@ +=head1 NAME + +XML::LibXML::Namespace - XML::LibXML Namespace Implementation + +=head1 SYNOPSIS + + + + use XML::LibXML; + # Only methods specific to Namespace nodes are listed here, + # see 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(); + +=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" + + + +=back + +=head1 AUTHORS + +Matt Sergeant, +Christian Glahn, +Petr Pajas + + +=head1 VERSION + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Node.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Node.pod new file mode 100755 index 00000000000..5af4f0fe22b --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Node.pod @@ -0,0 +1,752 @@ +=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 ); + $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( $chilnode ); + $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 ); + print $node->findvalue( $xpath ); + $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); + $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. A +LibXML::Node should never be created standalone, but as an instance of a high +level class such as LibXML::Element or 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 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 terminated. 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<<<<<< oldNode >>>>>> 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( $chilnode ); + +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 childnodes 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). + + +=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 Childnodes this function returns TRUE (1), otherwise it +returns FALSE (0, not undef). + + +=item firstChild + + $childnode = $node->firstChild; + +If a node has childnodes this function will return the first node in the +childlist. + + +=item lastChild + + $childnode = $node->lastChild; + +If the C<<<<<< $node >>>>>> has childnodes 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 a L<<<<<< XML::LibXML::NodeList >>>>>> object. + +The xpath expression can be passed either as a string or 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->find('/html') >>>>>> since C<<<<<< '/html' >>>>>> would only match if the root element C<<<<<< <html> >>>>>> 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 ); + +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 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. + +The xpath expression can be passed either as a string or or as a L<<<<<< XML::LibXML::XPathExpression >>>>>> object. + +See also L<<<<<< XML::LibXML::XPathContext >>>>>>->find. + + +=item findvalue + + print $node->findvalue( $xpath ); + +I<<<<<< findvalue >>>>>> is exactly equivalent to: + + + + $node->find( $xpath )->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 <xsl:value-of +select="some_xpath"/>. + +See also L<<<<<< XML::LibXML::XPathContext >>>>>>->findvalue. + +The xpath expression can be passed either as a string or 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 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 a 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 + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/NodeList.pm b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/NodeList.pm new file mode 100755 index 00000000000..336740803a2 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/NodeList.pm @@ -0,0 +1,198 @@ +# $Id: NodeList.pm 785 2009-07-16 14:17:46Z 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::NodeList; +use strict; +use XML::LibXML::Boolean; +use XML::LibXML::Literal; +use XML::LibXML::Number; + +use vars qw ($VERSION); +$VERSION = "1.70"; # VERSION TEMPLATE: DO NOT CHANGE + +use overload + '""' => \&to_literal, + 'bool' => \&to_boolean, + ; + +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]; +} + +*item = \&get_node; + +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('', grep {defined $_} map { $_->string_value } @$self) + ); +} + +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; +} + +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() + +You will almost never have to create a new NodeSet 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 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 NodeSet. + +=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($nodeset) + +Given a nodelist, prepends the list of nodes in $nodelist to the front of +the current list. + +=head2 iterator() + +Will return a new nodelist iterator for the current nodelist. A +nodelist iterator is usefull if more complex nodelist processing is +needed. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Number.pm b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Number.pm new file mode 100755 index 00000000000..5538d33e70a --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Number.pm @@ -0,0 +1,97 @@ +# $Id: Number.pm 785 2009-07-16 14:17:46Z 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::Number; +use XML::LibXML::Boolean; +use XML::LibXML::Literal; +use strict; + +use vars qw ($VERSION); +$VERSION = "1.70"; # 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 "<Number>" . (defined($$self) ? $$self : 'NaN') . "</Number>\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 diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/PI.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/PI.pod new file mode 100755 index 00000000000..1c08a8ab3b1 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/PI.pod @@ -0,0 +1,87 @@ +=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 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: + + + + <?abc foo="bar" foobar="foobar"?> + +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 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 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 + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Parser.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Parser.pod new file mode 100755 index 00000000000..1bf6b48d527 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Parser.pod @@ -0,0 +1,966 @@ +=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({ + 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 + +A 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 >>>>>>, C<<<<<< expand_entities >>>>>>, and C<<<<<< huge >>>>>> 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({ + 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 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. + + +=item load_xml + + + $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. + + +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. a 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 a XML Document +(see options section below). XML::LibXML allows 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 an 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 a XML document that is +available as a single string in memory. Again, you can pass an optional base +URI to the function. + + + + 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 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 + + +=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( "<foo>", "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( "<foo>", "bar" ); + $doc = $parser->finish_push(1); # will return the data parsed + # unless an error happened + }; + + print $doc->toString(); # returns "<foo>bar</foo>" + +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<<<<<< <foo></foo> >>>>>> rather than I<<<<<< <foo/> >>>>>>. + + +=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->new({name=>value, ...}) >>>>>> or C<<<<<< XML::LibXML->new(name=>value,...) >>>>>>. The options can be queried and changed using the following methods (pre-1.70 +interfaces such as C<<<<<< $parser->load_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 labeled + +=over 4 + +=item /parser/ + +if it can be used with a C<<<<<< XML::LibXML >>>>>> parser object (i.e. passed to C<<<<<< XML::LibXML->new >>>>>>, C<<<<<< XML::LibXML->set_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. Unfortunatelly, 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 a +XML_ENTITY_REF_NODE node whose subtree will be the content obtained by parsing +the external resource; Although this is level of 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 was +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 expand_xinclude or xinclude + +/parser, reader/ + +Implement XInclude substitution; possible values are 0 and 1 + +Expands XIinclude 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 1. + + +=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 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 an oposite 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 oposite 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. + + + +=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 + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Pattern.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Pattern.pod new file mode 100755 index 00000000000..f8a05c67b91 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Pattern.pod @@ -0,0 +1,107 @@ +=head1 NAME + +XML::LibXML::Pattern - XML::LibXML::Pattern - interface to libxml2 XPath patterns + +=head1 SYNOPSIS + + + + use XML::LibXML; + my $pattern = new XML::LibXML::Pattern('/x:html/x:body//x:div', { 'x' => 'http://www.w3.org/1999/xhtml' }); + # test a match on a XML::LibXML::Node $node + + if ($pattern->matchesNode($node)) { ... } + + # or on a 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 limitted 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<<<<<< <a xmlns="http://foo.bar"</a> >>>>>>, 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 a 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 + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Reader.pm b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Reader.pm new file mode 100755 index 00000000000..ec7b54451ab --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Reader.pm @@ -0,0 +1,212 @@ +# $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; + +use vars qw ($VERSION); +$VERSION = "1.70"; # 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 +}; +use vars qw( @EXPORT @EXPORT_OK %EXPORT_TAGS ); + +sub CLONE_SKIP { 1 } + +BEGIN { + +%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 + )] +); +@EXPORT = (@{$EXPORT_TAGS{types}},@{$EXPORT_TAGS{states}}); +@EXPORT_OK = @EXPORT; +$EXPORT_TAGS{all}=\@EXPORT_OK; +} + +{ + 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 ); + $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__ diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Reader.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Reader.pod new file mode 100755 index 00000000000..5c787ba3b30 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Reader.pod @@ -0,0 +1,669 @@ +=head1 NAME + +XML::LibXML::Reader - XML::LibXML::Reader - interface to libxml2 pull parser + +=head1 SYNOPSIS + + + + use XML::LibXML::Reader; + + + + my $reader = new XML::LibXML::Reader(location => "file.xml") + or die "cannot read file.xml\n"; + while ($reader->read) { + processNode($reader); + } + + + + sub processNode { + $reader = shift; + printf "%d %d %s %d\n", ($reader->depth, + $reader->nodeType, + $reader->name, + $reader->isEmptyElement); + } + +or + + + + $reader = new XML::LibXML::Reader(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-parser (StAX in Java, +XmlReader in C#) use an iterator approach to parse a xml-file. 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 in the way. At every point DOM-like methods of the Reader object +allow 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 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 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 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 >>>>>> (specificly 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 +<a/> will be considered empty while <a></a> 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 cannonical 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, <H.Klein@gmx.net<gt> and Petr Pajas + +=head1 AUTHORS + +Matt Sergeant, +Christian Glahn, +Petr Pajas + + +=head1 VERSION + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/RegExp.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/RegExp.pod new file mode 100755 index 00000000000..509de9f5ffd --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/RegExp.pod @@ -0,0 +1,71 @@ +=head1 NAME + +XML::LibXML::RegExp - XML::LibXML::RegExp - interface to libxml2 regular expressions + +=head1 SYNOPSIS + + + + use XML::LibXML; + my $compiled_re = new XML::LibXML::RegExp('[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 + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/RelaxNG.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/RelaxNG.pod new file mode 100755 index 00000000000..7c2e530aadb --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/RelaxNG.pod @@ -0,0 +1,81 @@ +=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 ); + $rngschema = XML::LibXML::RelaxNG->new( string => $xmlschemastring ); + $rngschema = XML::LibXML::RelaxNG->new( DOM => $doc ); + 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 ); + $rngschema = XML::LibXML::RelaxNG->new( string => $xmlschemastring ); + $rngschema = XML::LibXML::RelaxNG->new( DOM => $doc ); + +The constructor of XML::LibXML::RelaxNG may get called with either one of three +parameters. The parameter tells the class from which source it should generate +a validation schema. It is important, that each schema only have a single +source. + +The location parameter allows to parse a schema from the filesystem or a URL. + +The string parameter will parse the schema from the given XML string. + +The DOM parameter allows 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 to validate a (parsed) document against the given RelaxNG +schema. The argument of this function should be a 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 + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/SAX.pm b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/SAX.pm new file mode 100755 index 00000000000..8877240b5e6 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/SAX.pm @@ -0,0 +1,97 @@ +# $Id: SAX.pm 785 2009-07-16 14:17:46Z 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; + +use strict; +use vars qw($VERSION @ISA); + +$VERSION = "1.70"; # VERSION TEMPLATE: DO NOT CHANGE + +use XML::LibXML; +use XML::SAX::Base; + +use base qw(XML::SAX::Base); + +use Carp; +use IO::File; + +sub CLONE_SKIP { + return $XML::LibXML::__threads_shared ? 0 : 1; +} + +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" ); +} + +sub _parse_bytestream { + my ( $self, $fh ) = @_; + $self->{ParserOptions}{LibParser} = XML::LibXML->new; + $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} = XML::LibXML->new; + $self->{ParserOptions}{LibParser} = XML::LibXML->new() 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} = XML::LibXML->new; + $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} = XML::LibXML->new; + $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); + + $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; + diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/SAX.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/SAX.pod new file mode 100755 index 00000000000..0a892598f00 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/SAX.pod @@ -0,0 +1,49 @@ +=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 a 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. + +I<<<<<< NOTE: >>>>>> At the moment XML::LibXML provides only an incomplete interface to libxml2's +native SAX implementation. The current implementation is not tested in +production environment. It may causes significant memory problems or shows +wrong behaviour. If you run into specific problems using this part of +XML::LibXML, let me know. + +=head1 AUTHORS + +Matt Sergeant, +Christian Glahn, +Petr Pajas + + +=head1 VERSION + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/SAX/Builder.pm b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/SAX/Builder.pm new file mode 100755 index 00000000000..8ebd042ddd0 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/SAX/Builder.pm @@ -0,0 +1,332 @@ +# $Id: Builder.pm 785 2009-07-16 14:17:46Z 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::Builder; + +use XML::LibXML; +use XML::NamespaceSupport; + +use vars qw ($VERSION); + +sub CLONE_SKIP { + return $XML::LibXML::__threads_shared ? 0 : 1; +} + +$VERSION = "1.70"; # 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__ diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/SAX/Builder.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/SAX/Builder.pod new file mode 100755 index 00000000000..4d327a76ec3 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/SAX/Builder.pod @@ -0,0 +1,51 @@ +=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 + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/SAX/Generator.pm b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/SAX/Generator.pm new file mode 100755 index 00000000000..337b0277734 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/SAX/Generator.pm @@ -0,0 +1,157 @@ +# $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 XML::LibXML; +use vars qw ($VERSION); + +$VERSION = "1.70"; # 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("</" . $node->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 DEPRACED! 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 diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/SAX/Parser.pm b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/SAX/Parser.pm new file mode 100755 index 00000000000..086997970d3 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/SAX/Parser.pm @@ -0,0 +1,265 @@ +# $Id: Parser.pm 785 2009-07-16 14:17:46Z 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::Parser; + +use strict; +use vars qw($VERSION @ISA); + +use XML::LibXML; +use XML::LibXML::Common qw(:libxml); +use XML::SAX::Base; +use XML::SAX::DocumentLocator; + +$VERSION = "1.70"; # VERSION TEMPLATE: DO NOT CHANGE +@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("</" . $node->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) { + # some times it is just usefull 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__ diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Schema.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Schema.pod new file mode 100755 index 00000000000..2697ccc9c54 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Schema.pod @@ -0,0 +1,78 @@ +=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 ); + $xmlschema = XML::LibXML::Schema->new( string => $xmlschemastring ); + 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 ); + $xmlschema = XML::LibXML::Schema->new( string => $xmlschemastring ); + +The constructor of XML::LibXML::Schema may get called with either one of two +parameters. The parameter tells the class from which source it should generate +a validation schema. It is important, that each schema only have a single +source. + +The location parameter allows to parse a schema from the filesystem or a 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 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 + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Text.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Text.pod new file mode 100755 index 00000000000..f29b2fd100f --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/Text.pod @@ -0,0 +1,183 @@ +=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 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. Therefor 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 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 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 + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/XPathContext.pm b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/XPathContext.pm new file mode 100755 index 00000000000..81408dbd84d --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/XPathContext.pm @@ -0,0 +1,146 @@ +# $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 vars qw($VERSION @ISA $USE_LIBXML_DATA_TYPES); + +use Carp; +use XML::LibXML; +use XML::LibXML::NodeList; + +$VERSION = "1.70"; # VERSION TEMPLATE: DO NOT CHANGE + +# should LibXML XPath data types be used for simple objects +# when passing parameters to extension functions (default: no) +$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; diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/XPathContext.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/XPathContext.pod new file mode 100755 index 00000000000..80ceff6435e --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/XPathContext.pod @@ -0,0 +1,372 @@ +=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) + @nodes = $xpc->findnodes($xpath, $context_node ) + $nodelist = $xpc->findnodes($xpath, $context_node ) + $object = $xpc->find($xpath ) + $object = $xpc->find($xpath, $context_node ) + $value = $xpc->findvalue($xpath ) + $value = $xpc->findvalue($xpath, $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) +The XML::LibXML::XPathContext class provides an almost complete interface to +libxml2's XPath implementation. With XML::LibXML::XPathContext is 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<<<<<< $prefix >>>>>>. 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 a 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) + + @nodes = $xpc->findnodes($xpath, $context_node ) + + $nodelist = $xpc->findnodes($xpath, $context_node ) + +Performs the xpath statement on the current node and returns the result as an +array. In scalar context returns a 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 or as a L<<<<<< XML::LibXML::XPathExpression >>>>>> object. + + +=item find + + $object = $xpc->find($xpath ) + + $object = $xpc->find($xpath, $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 a 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 or as a L<<<<<< XML::LibXML::XPathExpression >>>>>> object. + + +=item findvalue + + $value = $xpc->findvalue($xpath ) + + $value = $xpc->findvalue($xpath, $context_node ) + +Is exactly equivalent to: + + + + $xpc->find( $xpath, $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 <xsl:value-of select=``some_xpath''/>. +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 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 + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut diff --git a/Master/tlpkg/tlperl.straw/lib/XML/LibXML/XPathExpression.pod b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/XPathExpression.pod new file mode 100755 index 00000000000..742b8747450 --- /dev/null +++ b/Master/tlpkg/tlperl.straw/lib/XML/LibXML/XPathExpression.pod @@ -0,0 +1,65 @@ +=head1 NAME + +XML::LibXML::XPathExpression - XML::LibXML::XPathExpression - interface to libxml2 pre-compiled XPath expressions + +=head1 SYNOPSIS + + + + use XML::LibXML; + my $compiled_xpath = new XML::LibXML::XPathExpression('//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 + +1.70 + +=head1 COPYRIGHT + +2001-2007, AxKit.com Ltd. + +2002-2006, Christian Glahn. + +2006-2009, Petr Pajas. + +=cut |