Commits

Shlomi Fish committed 33f8a60

Removed trailing space from docs/libxml.dbk.

Comments (0)

Files changed (2)

 > libxml2:
 > 
 > must set SHLIB_PATH  to include  the path to  libxml2 shared library
->  
+> 
 > assuming that you used the default:
 > 
 > export  SHLIB=/usr/local/lib
 > 
 > /usr/local/bin/xml2-config
 > /usr/local/bin/xslt-config
->  
+> 
 > they did not have +x after they were installed by 'make install'
 > and it took me a while to realize that this was my problem
->  
+> 
 > or one can use:
 > 
 > perl Makefile.PL LIBS='-L/path/to/lib' INC='-I/path/to/include'
                 <para>Usually it takes a little time to build the package for the latest release.</para>
 		<para>If you want to build XML::LibXML on Windows from source, you can use
 		the following instructions contributed by Christopher J. Madsen:</para>
- 
+
 		<para>These instructions assume that you already have your system set up to
 		compile modules that use C components.
 		</para>
 libxml2:
 
 must set SHLIB_PATH  to include  the path to  libxml2 shared library
- 
+
 assuming that you used the default:
 
 export  SHLIB=/usr/local/lib
 
 /usr/local/bin/xml2-config
 /usr/local/bin/xslt-config
- 
+
 they did not have +x after they were installed by 'make install'
 and it took me a while to realize that this was my problem
- 
+
 or one can use:
 
 perl Makefile.PL LIBS='-L/path/to/lib' INC='-I/path/to/include'</programlisting>
         <sect1>
             <title>Description</title>
 
-            <para>This module is an interface to libxml2, providing 
+            <para>This module is an interface to libxml2, providing
 	    XML and HTML parsers with DOM, SAX and XMLReader interfaces,
-	    a large subset of DOM Layer 3 interface and 
-	    a  XML::XPath-like interface to XPath API of libxml2. 
+	    a large subset of DOM Layer 3 interface and
+	    a  XML::XPath-like interface to XPath API of libxml2.
 	    The module is split into several packages which are not described in this section;
 	    unless stated otherwise, you only need to <literal>use XML::LibXML;</literal>
 	    in your programs.</para>
             character strings (internally encoded in UTF-8) and so
             called binary data and, accordingly, applies either
             character or byte semantics to them.  A scalar
-            representing a character string is distinguished from 
+            representing a character string is distinguished from
 	    a byte string by special flag (UTF8). Please refer to <emphasis>perlunicode</emphasis> for details.
 	    </para>
 	    <para>
 	      that the application using XML::LibXML can be completely
 	      ignorant about the encoding of the XML documents it works with.
 	      On the other hand, functions like <function>XML::LibXML::Document-&gt;setEncoding</function>
-	      give the user control over the document encoding. 
+	      give the user control over the document encoding.
 	    </para>
 	    <para>
 	      To ensure the aforementioned transparency and
 	      and saving) operate with binary data (in the original
 	      document encoding) obeying the encoding declaration of
 	      the XML documents.</para>
-	    <para>Below we summarize basic rules and principles 
+	    <para>Below we summarize basic rules and principles
 	    regarding encoding:
 	    </para>
 	    <orderedlist>
 		and <literal>$name</literal> and <literal>$text</literal>
 		contain character strings (UTF-8 encoded with UTF8 flag on).
 		Note that the method <function>toString</function>
-		returns XML as a character string if applied to 
-		other node than the Document node and 
+		returns XML as a character string if applied to
+		other node than the Document node and
 		a byte string containing the apropriate
 		<programlisting>&lt;?xml version="1.0" encoding="..."?&gt;</programlisting>
 		declaration if applied to a <xref linkend="XML-LibXML-Document"/>.
 	   in the spawned thread as in the main thread.
 	 </para>
 	 <para>
-	   Without using mutex locks, 
+	   Without using mutex locks,
 	   parallel threads may read the same document
 	   (i.e. any node that belongs to the document),
 	   parse files, and modify different documents.
 	 </para>
 	 <para>
 	   However, if there is a chance that
-	   some of the threads will attempt to modify a document 
+	   some of the threads will attempt to modify a document
 	   (or even create
 	   new nodes based on that document,
 	   e.g. with <literal>$doc->createElement</literal>)
    # ...
   1;
 });
-{ 
+{
   lock $mutex;
   my $root = $doc->documentElement;
   say $root->name;
                         "20602-CVS2032" for a CVS build of
                         libxml2.</para>
                         <para>XML::LibXML issues a warning if the version
-                         of libxml2 dynamically linked to it is less than the version of libxml2 
-                         which it was compiled against. 
+                         of libxml2 dynamically linked to it is less than the version of libxml2
+                         which it was compiled against.
                          </para>
                     </listitem>
                 </varlistentry>
 	    <varlistentry>
 	      <term><literal>:all</literal></term>
 	      <listitem>
-		<para>Includes the tags <literal>:libxml</literal>, <literal>:encoding</literal>, and 
+		<para>Includes the tags <literal>:libxml</literal>, <literal>:encoding</literal>, and
 		<literal>:ns</literal> described below.</para>
 	      </listitem>
 	    </varlistentry>
                             <para>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 
+			      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
 			  to a DOM tree. The arguments
 			  can be passed in a HASH reference
 			  or as name => value pairs.
-			  The function can be called 
+			  The function can be called
 			  as a class method or an object method.
 			  In both cases it internally creates a new
 			  parser instance passing
 			  its settings) and additionally applies
 			  the specified options to the new parser.
 			  See the constructor <function>new</function>
-			  and <xref linkend="parser-options"/> 
+			  and <xref linkend="parser-options"/>
 			  for more information.
 			  </para>
 			  </listitem>
                             </para>
                             <para>An optional second argument can be
                                used to pass some options to the HTML
-                               parser as a HASH reference. 
+                               parser as a HASH reference.
 			       See options labeled with HTML in <xref linkend="parser-options"/>.
 	                    </para>
                         </listitem>
             <sect2>
                 <title>DOM based SAX Parser</title>
 
-                <para>XML::LibXML also provides a DOM based SAX parser. The SAX parser is defined in 
+                <para>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.</para>
 
 
 	    <para>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 <literal>XML::LibXML->new({name=>value, ...})</literal> 
+	      passing them to the constructor as <literal>XML::LibXML->new({name=>value, ...})</literal>
 	      or <literal>XML::LibXML->new(name=>value,...)</literal>.
 	      The options can be queried and changed using the following methods (pre-1.70 interfaces such as <function>$parser->load_ext_dtd(0)</function> also exist, see below):
 	    </para>
             <term>line_numbers</term>
             <listitem>
 	      <para>/parser, html, reader/</para>
-              <para>If this option is activated, libxml2 will store the line number of each element node in the parsed document. 
+              <para>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 <function>line_number()</function> method
 		of the <function>XML::LibXML::Node</function> class (for non-element nodes
-		this may report the line number of the containing element). 
+		this may report the line number of the containing element).
 		The line numbers are also used for reporting positions of validation errors.
 	      </para>
 	      <para>IMPORTANT:
 		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, 
+		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.</para>
 	      whose subtree will be the content obtained by parsing the external resource;
 	      Although this nesting is visible from the DOM
 	      it is transparent to XPath data model, so it is possible to
-	      match nodes in an unexpanded entity by the same XPath expression 
+	      match nodes in an unexpanded entity by the same XPath expression
 	      as if the entity were expanded. See also ext_ent_handler.
 	      </para>
 	    </listitem>
 sub match {   # accept file:/ URIs except for XML catalogs in /etc/xml/
   my ($uri) = @_;
   return ($uri=~m{^file:/}
-          and $uri !~ m{^file:///etc/xml/}) 
+          and $uri !~ m{^file:///etc/xml/})
          ? 1 : 0;
 }
 $c->register_callbacks([ \&amp;match, sub{}, sub{}, sub{} ]);
             <term>load_ext_dtd</term>
             <listitem>
 	      <para>/parser, reader/</para>
-              <para>load the external DTD subset while parsing; possible values are 0 and 1. Unless specified, 
+              <para>load the external DTD subset while parsing; possible values are 0 and 1. Unless specified,
 		XML::LibXML sets this option to 1.</para>
               <para>This flag is also required for DTD Validation, to provide complete attribute,
                 and to expand entities, regardless if the document has an internal subset.
             <listitem>
 	      <para>/parser, reader/</para>
               <para>Implement XInclude substitution; possible values are 0 and 1</para>
-              <para>Expands XIinclude tags immediately while parsing the document. 
+              <para>Expands XIinclude tags immediately while parsing the document.
 		Note that the parser will use the URI resolvers installed
 		via <function>XML::LibXML::InputCallback</function> to parse the included document (if any).</para>
             </listitem>
             <term>huge</term>
             <listitem>
 	      <para>/parser, html, reader/</para>
-              <para>relax any hardcoded limit from the parser; possible values are 0 and 1. Unless specified, 
+              <para>relax any hardcoded limit from the parser; possible values are 0 and 1. Unless specified,
 		XML::LibXML sets this option to 1.</para>
             </listitem>
           </varlistentry>
                 use of XML::LibXML's full parser options and XML::GDOME's DOM implementation at the same time.</para>
               <para>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!</para>
-	      <para>Note: this feature was not seriously tested in recent XML::LibXML releases.</para> 
+	      <para>Note: this feature was not seriously tested in recent XML::LibXML releases.</para>
             </listitem>
 	  </varlistentry>
 	</variablelist>
 	      </para>
 	      <para>
 		Note that libxml2 has a global pool of loaded catalogs,
-		so if you apply the method <literal>load_catalog</literal> 
+		so if you apply the method <literal>load_catalog</literal>
 		to one parser instance, all parser instances will start using the catalog
 		(in addition to other previously loaded catalogs).
 	      </para>
 
             <para><emphasis>NOTE:</emphasis> This feature is experimental. </para>
 
-            <para>You can enable character data joining which may yield a 
+            <para>You can enable character data joining which may yield a
             significant speed boost in your XML processing in lower markup
-            ratio situations by enabling the 
-            http://xmlns.perl.org/sax/join-character-data feature of this 
-            parser. This is done via the set_feature method like 
-            this: 
-            </para> 
-            
-            <programlisting>$p->set_feature('http://xmlns.perl.org/sax/join-character-data', 1); 
+            ratio situations by enabling the
+            http://xmlns.perl.org/sax/join-character-data feature of this
+            parser. This is done via the set_feature method like
+            this:
+            </para>
+
+            <programlisting>$p->set_feature('http://xmlns.perl.org/sax/join-character-data', 1);
             </programlisting>
 
             <para>
             You can also specify a 0 to disable. The default is to have
-            this feature disabled. 
+            this feature disabled.
             </para>
         </sect1>
     </chapter>
 	    <sect2>
 	      <title>Namespaces and XML::LibXML's DOM implementation</title>
 
-            <para>XML::LibXML's DOM implementation is 
+            <para>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.
 		    </para>
 		    <para>In versions 1.59 and earlier this method was
 		      called getElementsById() (plural) by
-		      mistake. Starting from 1.60 this name is 
+		      mistake. Starting from 1.60 this name is
 		      maintained as an alias only for backward compatibility.
 		    </para>
                 </listitem>
 	            </para>
                     <para>Since 1.62 this function also returns the correct
 	              DOM names for node types with constant names, namely:
-                      #text, #cdata-section, #comment, #document, 
+                      #text, #cdata-section, #comment, #document,
 	              #document-fragment.
 	            </para>
                 </listitem>
             </varlistentry>
-        
+
             <varlistentry>
                 <term>setNodeName</term>
 
                     aware of namespaces.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>isSameNode</term>
 
                     returned.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>isEqual</term>
 
                     <para><emphasis>NOTE</emphasis> isEqual will change behaviour to follow the DOM specification</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>nodeValue</term>
 
                     instead!</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>textContent</term>
 
                     <para>this function returns the content of all text nodes in the descendants of the given node as specified in DOM.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>nodeType</term>
 
 		    <xref linkend="XML-LibXML"/> manual page).</para>
                 </listitem>
             </varlistentry>
-	
+
             <varlistentry>
                 <term>unbindNode</term>
 
                     inserted into a (hidden) document-fragment.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>removeChild</term>
 
                     <function>oldNode</function> is not a child of the given Node the function will fail.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>replaceChild</term>
 
                     be imported first.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>replaceNode</term>
 
                     found by any XPath function, should be replaced.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>appendChild</term>
 
                     case, if the new node is not part of the document, the node will be imported first.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>addChild</term>
 
                     the sense of being more error tolerant.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>addNewChild</term>
 
                     this function is not part of the DOM specification and its use will limit your code to XML::LibXML.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>addSibling</term>
 
                     <para>addSibling() allows adding an additional node to the end of a nodelist, defined by the given node.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>cloneNode</term>
 
                       was not copied for elements).</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>parentNode</term>
 
                     <para>Returns simply the Parent Node of the current node.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>nextSibling</term>
 
                     <para>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.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>previousSibling</term>
 
                     <para>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.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>hasChildNodes</term>
 
                     <para>If the current node has Childnodes this function returns TRUE (1), otherwise it returns FALSE (0, not undef).</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>firstChild</term>
 
                     <para>If a node has childnodes this function will return the first node in the childlist.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>lastChild</term>
 
                     <para>If the <function>$node</function> has childnodes this function returns the last child node.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>ownerDocument</term>
 
                     <para>Through this function it is always possible to access the document the current node is bound to.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>getOwner</term>
 
                     node.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>setOwnerDocument</term>
 
                     with Entity References as adoptNode().</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>insertBefore</term>
 
                     ancestor of the new parent node.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>insertAfter</term>
 
                     <para>Note, that $refNode has to be passed explicitly even if it is undef.</para>
                 </listitem>
             </varlistentry>
-        
+
             <varlistentry>
                 <term>findnodes</term>
 
                     </funcsynopsis>
 
                     <para><emphasis>findnodes</emphasis> 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 <olink targetdoc="XML::LibXML::NodeList">XML::LibXML::NodeList</olink> object.</para>
-          <para>The xpath expression can be passed either as a string or 
+          <para>The xpath expression can be passed either as a string or
 	  or as a  <olink targetdoc="XML::LibXML::XPathExpression">XML::LibXML::XPathExpression</olink> object.
 	  </para>
 	  <para><emphasis>NOTE ON NAMESPACES AND XPATH</emphasis>:</para>
 	    </listitem>
 	    <listitem><para>
 		Another possibility is to use prefixes declared
-		in the queried document (if known). 
+		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),
 	  <para>See also XML::LibXML::XPathContext-&gt;findnodes.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>find</term>
 
                     <olink targetdoc="XML::LibXML::Number">XML::LibXML::Number</olink> object being returned. Other expressions might return a <olink targetdoc="XML::LibXML::Boolean">XML::LibXML::Boolean</olink>
                     object, or a <olink targetdoc="XML::LibXML::Literal">XML::LibXML::Literal</olink> object (a string). Each of those objects uses Perl's overload feature to "do
                     the right thing" in different contexts.</para>
-          <para>The xpath expression can be passed either as a string or 
+          <para>The xpath expression can be passed either as a string or
 	  or as a  <olink targetdoc="XML::LibXML::XPathExpression">XML::LibXML::XPathExpression</olink> object.
 	  </para>
 	  <para>See also <xref linkend="XML-LibXML-XPathContext"/>-&gt;find.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>findvalue</term>
 
                     <para>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 &lt;xsl:value-of select="some_xpath"/&gt;.</para>
 	  <para>See also <xref linkend="XML-LibXML-XPathContext"/>-&gt;findvalue.</para>
-          <para>The xpath expression can be passed either as a string or 
+          <para>The xpath expression can be passed either as a string or
 	  or as a  <olink targetdoc="XML::LibXML::XPathExpression">XML::LibXML::XPathExpression</olink> object.
 	  </para>
                 </listitem>
             </varlistentry>
-        
+
             <varlistentry>
                 <term>exists</term>
 
 		    the method returns true if the returned value is a non-zero number or a non-empty string.</para>
 		</listitem>
 	    </varlistentry>
-        
+
             <varlistentry>
                 <term>childNodes</term>
 
                     <olink targetdoc="XML::LibXML::NodeList">XML::LibXML::NodeList</olink> object will be returned.</para>
                 </listitem>
             </varlistentry>
-        
+
             <varlistentry>
                 <term>nonBlankChildNodes</term>
 
 		      (where a node is blank if it is a Text or CDATA node consisting of whitespace only). This method is not defined by DOM.</para>
                 </listitem>
             </varlistentry>
-        
+
             <varlistentry>
                 <term>toString</term>
 
 		    <para>
 		      An optional parameter $xpath_context can be used
 		      to pass an <xref linkend="XML-LibXML-XPathContext"/> object defining
-		      the context for evaluation of $xpath_expression. 
-		      This is useful for mapping namespace prefixes used in the XPath expression 
+		      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 XML-EXC-C14N Specification (see <ulink url="http://www.w3.org/TR/xml-exc-c14n">http://www.w3.org/TR/xml-exc-c14n</ulink>)
 	            for exclusive canonization of XML.</para>
 
-                    <para>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, 
+                    <para>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.
 	            </para>
                 </listitem>
                     <para>An alias for toStringEC14N().</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>localname</term>
 
                     <para>Returns the local name of a tag. This is the part behind the colon.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>prefix</term>
 
                     <para>Returns the prefix of a tag. This is the part before the colon.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>namespaceURI</term>
 
                     <para>returns the URI of the current namespace.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>hasAttributes</term>
 
                     <para>returns 1 (TRUE) if the current node has any attributes set, otherwise 0 (FALSE) is returned.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>attributes</term>
 
                     <olink targetdoc="XML::LibXML::NamedNodeMap">XML::LibXML::NamedNodeMap</olink> object.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>lookupNamespaceURI</term>
 
                     <para>Find a namespace URI by its prefix starting at the current node.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>lookupNamespacePrefix</term>
 
                     have more than a single prefix defined for a namespace.</para>
                 </listitem>
             </varlistentry>
-        
-        
+
+
             <varlistentry>
                 <term>normalize</term>
 
                     not free a node that is still referenced by the perl layer.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>getNamespaces</term>
 
                     <para>Although getNamespaces is available for all nodes, it only makes sense if used with element nodes.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>removeChildNodes</term>
 
                     violations, if there are nodes still referred to from the Perl level.</para>
                 </listitem>
             </varlistentry>
-        
+
         <varlistentry>
           <term>baseURI ()</term>
           <listitem>
 	    <para>
 	    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 
+	    set the base URI of the node. See RFC 2396 appendix D
 	    for an example of how base URI can be specified in HTML.
 	    </para>
           </listitem>
         </varlistentry>
-        
+
             <varlistentry>
                 <term>nodePath</term>
 
                     <para>This function is not specified for any DOM level: It returns a canonical structure based XPath for a given node.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>line_number</term>
 
 	<sect1>
 	  <title>Methods</title>
 	  <para>
-	    The class inherits from <xref linkend="XML-LibXML-Node"/>. 
+	    The class inherits from <xref linkend="XML-LibXML-Node"/>.
 	    The documentation for Inherited methods is not listed here.
 	  </para>
 	  <para>
                     <para>This function creates a new node unbound to any DOM.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>setAttribute</term>
 
                     <para>This method sets or replaces the node's attribute <function>$aname</function> to the value <function>$avalue</function></para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>setAttributeNS</term>
 
                     </para>
 	            <para>
                        If an attribute with the same local name and namespace URI already exists
-                       on the element, but its prefix differs from the prefix of <function>$aname</function>, 
+                       on the element, but its prefix differs from the prefix of <function>$aname</function>,
                        then this function is supposed to change the prefix (regardless
                        of namespace declarations and possible collisions).
                        However, the current implementation does rather the opposite.
                     </para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>getAttribute</term>
 
                     returned.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>getAttributeNS</term>
 
                     <para>Retrieves an attribute value by local name and namespace URI.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>getAttributeNode</term>
 
                     <para>Retrieve an attribute node by name. If no attribute with a given name exists, <function>undef</function> is returned.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>getAttributeNodeNS</term>
 
                     <para>Retrieves an attribute node by local name and namespace URI. If no attribute with a given localname and namespace exists, <function>undef</function> is returned.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>removeAttribute</term>
 
                     <para>The method removes the attribute <function>$aname</function> from the node's attribute list, if the attribute can be found.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>removeAttributeNS</term>
 
                     <para>Namespace version of <function>removeAttribute</function></para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>hasAttribute</term>
 
                     return value is FALSE (0).</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>hasAttributeNS</term>
 
                     <para>namespace version of <function>hasAttribute</function></para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>getChildrenByTagName</term>
 
                     <para>If this function is called in SCALAR context, it returns the number of elements found.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>getChildrenByTagNameNS</term>
 
                     <para>If this function is called in SCALAR context, it returns the number of elements found.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>getChildrenByLocalName</term>
 
                     <para>If this function is called in SCALAR context, it returns the number of elements found.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>getElementsByTagName</term>
 
                     <para>In SCALAR context this function returns a <olink targetdoc="XML::LibXML::NodeList">XML::LibXML::NodeList</olink> object.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>getElementsByTagNameNS</term>
 
                     <para>In SCALAR context this function returns a <olink targetdoc="XML::LibXML::NodeList">XML::LibXML::NodeList</olink> object.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>getElementsByLocalName</term>
 
                     <para>In SCALAR context this function returns a <olink targetdoc="XML::LibXML::NodeList">XML::LibXML::NodeList</olink> object.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>appendWellBalancedChunk</term>
 
                     <para>This form is more explicit and makes it easier to control the flow of a script.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>appendText</term>
 
                     <para>alias for appendTextNode().</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>appendTextNode</term>
 
                     <para>This wrapper function lets you add a string directly to an element node.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>appendTextChild</term>
 
                     create multiple namespace declarations on a single
                     element.</para>
                     <para>The function fails if it is required to
-                      create a declaration associating the prefix 
+                      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.
 	             the change.
            	  </para>
 	          <para>If the new URI is undef or empty, the nodes
-	             have no namespace and no prefix after the change. 
+	             have no namespace and no prefix after the change.
 	             Namespace declarations
 	             once nulled in this way do not
 	             further appear in the serialized output
                      namespace declaration determines their namespace
 	             change their prefix to the new value.
            	  </para>
-	          <para>If the new prefix is undef or empty, 
+	          <para>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
         <sect1>
             <title>Methods</title>
 	  <para>
-	    The class inherits from <xref linkend="XML-LibXML-Node"/>. 
+	    The class inherits from <xref linkend="XML-LibXML-Node"/>.
 	    The documentation for Inherited methods is not listed here.
 	  </para>
 	  <para>
                     <para>The constructor of the class. It creates an unbound text node.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>data</term>
 
                     <para>will have the same result and are not different entities.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>setData($string)</term>
 
                     "comment".</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>substringData($offset,$length)</term>
 
                     If $length is out of range <function>substringData</function> will return the data starting at $offset instead of causing an error.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>appendData($string)</term>
 
                     <function>setData</function>.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>insertData($offset,$string)</term>
 
                     <function>appendData</function>.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>deleteData($offset, $length)</term>
 
                     be removed from the string.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>deleteDataString($string, [$all])</term>
 
                     from the node data.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>replaceData($offset, $length, $string)</term>
 
                     <para>The DOM style version to replace node data.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>replaceDataString($oldstring, $newstring, [$all])</term>
 
                     the <emphasis>$all</emphasis> flag allows to replace all occurrences of <emphasis>$oldstring</emphasis>.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>replaceDataRegEx( $search_cond, $replace_cond, $reflags )</term>
 
         </sect1>
         <sect1>
             <title>Description</title>
-	
+
         <para>This class provides all functions of <xref linkend="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. :-)</para>
 	</sect1>
         <sect1>
             <title>Methods</title>
 	  <para>
-	    The class inherits from <xref linkend="XML-LibXML-Node"/>. 
+	    The class inherits from <xref linkend="XML-LibXML-Node"/>.
 	    The documentation for Inherited methods is not listed here.
 	  </para>
 	  <para>
         <sect1>
             <title>Methods</title>
 	  <para>
-	    The class inherits from <xref linkend="XML-LibXML-Node"/>. 
+	    The class inherits from <xref linkend="XML-LibXML-Node"/>.
 	    The documentation for Inherited methods is not listed here.
 	  </para>
 	  <para>
         <sect1>
             <title>Methods</title>
 	  <para>
-	    The class inherits from <xref linkend="XML-LibXML-Node"/>. 
+	    The class inherits from <xref linkend="XML-LibXML-Node"/>.
 	    The documentation for Inherited methods is not listed here.
 	  </para>
 	  <para>
                     of <xref linkend="XML-LibXML-Document"/>.</para>
                 </listitem>
             </varlistentry>
-        
+
             <varlistentry>
                 <term>getValue</term>
 
                     <function>not specified</function>.</para>
                 </listitem>
             </varlistentry>
-                
+
             <varlistentry>
                 <term>value</term>
 
                     <para>Alias for <emphasis>getValue()</emphasis></para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>setValue</term>
 
                     otherwise the encoding might be done incorrectly.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>getOwnerElement</term>
 
                     implementation, the <emphasis>parentNode</emphasis> function will return undef, instead of the owner element.</para>
                 </listitem>
             </varlistentry>
-        
-
-        
+
+
+
             <varlistentry>
                 <term>setNamespace</term>
 
                     </funcsynopsis>
 
                     <para>This function tries to bound the attribute to a given namespace.
-            If <function>$nsURI</function> is undefined or empty, 
+            If <function>$nsURI</function> 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. 
+	    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 <function>$prefix</function>.
 	    The function also fails if the prefix is empty but the namespace URI
-	    is not (because unprefixed attributes should by definition belong to 
+	    is not (because unprefixed attributes should by definition belong to
 	    no namespace).
 	    This function returns 1 on success, 0 otherwise.
 	  </para>
                 </listitem>
             </varlistentry>
-        
-	
+
+
             <varlistentry>
                 <term>isId</term>
                 <listitem>
             <title>Synopsis</title>
 
             <programlisting>my $input_callbacks = XML::LibXML::InputCallback-&gt;new();
-$input_callbacks-&gt;register_callbacks([ $match_cb1, $open_cb1, 
+$input_callbacks-&gt;register_callbacks([ $match_cb1, $open_cb1,
                                        $read_cb1, $close_cb1 ] );
-$input_callbacks-&gt;register_callbacks([ $match_cb2, $open_cb2, 
+$input_callbacks-&gt;register_callbacks([ $match_cb2, $open_cb2,
                                        $read_cb2, $close_cb2 ] );
-$input_callbacks-&gt;register_callbacks( [ $match_cb3, $open_cb3, 
+$input_callbacks-&gt;register_callbacks( [ $match_cb3, $open_cb3,
                                         $read_cb3, $close_cb3 ] );
 
 $parser-&gt;input_callbacks( $input_callbacks );
                 <para>After object instantiation using the parameter-less constructor, you can register callback groups.</para>
 
                 <programlisting>my $input_callbacks = XML::LibXML::InputCallback-&gt;new();
-$input_callbacks-&gt;register_callbacks([ $match_cb1, $open_cb1, 
+$input_callbacks-&gt;register_callbacks([ $match_cb1, $open_cb1,
                                        $read_cb1, $close_cb1 ] );
-$input_callbacks-&gt;register_callbacks([ $match_cb2, $open_cb2, 
+$input_callbacks-&gt;register_callbacks([ $match_cb2, $open_cb2,
                                        $read_cb2, $close_cb2 ] );
-$input_callbacks-&gt;register_callbacks( [ $match_cb3, $open_cb3, 
+$input_callbacks-&gt;register_callbacks( [ $match_cb3, $open_cb3,
                                         $read_cb3, $close_cb3 ] );
 
 $parser-&gt;input_callbacks( $input_callbacks );
 
             <para>The following example is a purely fictitious example that uses a MyScheme::Handler object that responds to methods similar to an IO::Handle.</para>
 
-            <programlisting>   
+            <programlisting>
 # 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-&gt;new($uri);
     return $buffer; # $buffer will be an empty string '' if read() is done
 }
 
-# Close the handle associated with the resource.  
+# 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-&gt;new();
-$input_callbacks-&gt;register_callbacks([ \&amp;match_uri, \&amp;open_uri, 
+$input_callbacks-&gt;register_callbacks([ \&amp;match_uri, \&amp;open_uri,
                                        \&amp;read_uri, \&amp;close_uri ] );
 
 # Register the callback group at a parser instance
 $parser-&gt;input_callbacks( $input_callbacks );
 
-# $some_xml_file will be parsed using our callbacks 
+# $some_xml_file will be parsed using our callbacks
 $parser-&gt;parse_file( $some_xml_file );
 
 
             <title>Description</title>
 
         <para>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). 
+        document validation. As of 2.6.32, libxml2 only supports decimal types up to 24 digits (the standard requires at least 18).
 	</para>
 	</sect1>
         <sect1>
         <title>Custom XPath functions</title>
 <para>This example demonstrates <function>registerFunction()</function> method
 by defining a function filtering nodes based on a Perl regular expression:</para>
-	<programlisting>sub grep_nodes { 
+	<programlisting>sub grep_nodes {
   my ($nodelist,$regexp) =  @_;
   my $result = XML::LibXML::NodeList-&gt;new;
   for my $node ($nodelist-&gt;get_nodelist()) {
   my ($varname,$ns,$data)=@_;
   return $data-&gt;{$varname};
 }
-        
+
 my $areas = XML::LibXML-&gt;new-&gt;parse_file('areas.xml');
 my $empl = XML::LibXML-&gt;new-&gt;parse_file('employees.xml');
-        
+
 my $xc = XML::LibXML::XPathContext-&gt;new($empl);
-        
-my %variables = ( 
+
+my %variables = (
   A =&gt; $xc-&gt;find('/employees/employee[@salary&gt;10000]'),
-  B =&gt; $areas-&gt;find('/areas/area[district='Brooklyn']/street'), 
+  B =&gt; $areas-&gt;find('/areas/area[district='Brooklyn']/street'),
 );
-        
+
 # get names of employees from $A working in an area listed in $B
 $xc-&gt;registerVarLookupFunc(\&amp;var_lookup, \%variables);
 my @nodes = $xc-&gt;findnodes('$A[work_area/street = $B]/name');
 	      returns a <olink targetdoc="XML::LibXML::NodeList">XML::LibXML::NodeList</olink> object. Optionally, a
 	      node may be passed as a second argument to set the
 	      context node for the query.</para>
-          <para>The xpath expression can be passed either as a string or 
+          <para>The xpath expression can be passed either as a string or
 	  or as a  <olink targetdoc="XML::LibXML::XPathExpression">XML::LibXML::XPathExpression</olink> object.
 	  </para>
           </listitem>
 	      thing'' in different contexts. Optionally, a node may be
 	      passed as a second argument to set the context node for
 	      the query.</para>
-          <para>The xpath expression can be passed either as a string or 
+          <para>The xpath expression can be passed either as a string or
 	  or as a  <olink targetdoc="XML::LibXML::XPathExpression">XML::LibXML::XPathExpression</olink> object.
 	  </para>
           </listitem>
             select=``some_xpath''/&gt;. Optionally, a node may be
             passed in the second argument to set the context node for
             the query.</para>
-          <para>The xpath expression can be passed either as a string or 
+          <para>The xpath expression can be passed either as a string or
 	  or as a  <olink targetdoc="XML::LibXML::XPathExpression">XML::LibXML::XPathExpression</olink> object.
 	  </para>
           </listitem>
     </sect1>
     <sect1>
       <title>Authors</title>
-      <para>Ilya Martynov and Petr Pajas, based on 
-	XML::LibXML and XML::LibXSLT code by Matt Sergeant and 
-	Christian Glahn.</para> 
+      <para>Ilya Martynov and Petr Pajas, based on
+	XML::LibXML and XML::LibXSLT code by Matt Sergeant and
+	Christian Glahn.</para>
     </sect1>
     <sect1>
       <title>Historical remark</title>
       <title>DESCRIPTION</title>
       <para>This is a perl interface to libxml2's pull-parser implementation
 	xmlTextReader
-	<emphasis>http://xmlsoft.org/html/libxml-xmlreader.html</emphasis>. 
+	<emphasis>http://xmlsoft.org/html/libxml-xmlreader.html</emphasis>.
 	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
             <term>...</term>
             <listitem>
               <para>the reader further supports various
-	      parser options described in 
+	      parser options described in
 	      <xref linkend="XML-LibXML-Parser"/> (specificly those
 	      labeled by /reader/).
 	      </para>
             <para>Skip nodes following the current one in the document
 	      order until an element matching a given
 	      compiled pattern is reached. See
-              <xref linkend="XML-LibXML-Pattern"/> for information on 
+              <xref linkend="XML-LibXML-Pattern"/> for information on
 	      compiled patterns. See also the <literal>matchesPattern</literal>
 	      method.</para>
             <para>Returns 1 if the element was found, 0 if there is no more nodes to read, or -1 in case of error.</para>
         <varlistentry>
           <term>nodePath()</term>
           <listitem>
-            <para>Returns a cannonical location path to the current element 
+            <para>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 
+	    prefixes within XPath patterns. Unlike
 	    <literal>XML::LibXML::Node::nodePath()</literal>, 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).
           <listitem>
             <para>Returns a true value if the current
 	    node matches a compiled pattern.
-            See <xref linkend="XML-LibXML-Pattern"/> for information on 
+            See <xref linkend="XML-LibXML-Pattern"/> for information on
 	    compiled patterns. See also the <literal>nextPatternMatch</literal>
 	    method.</para>
           </listitem>
-        </varlistentry>	
+        </varlistentry>
       </variablelist>
     </sect1>
     <sect1>
           <term>baseURI ()</term>
           <listitem>
             <para>Returns the base URI of a given node.</para>
-          </listitem>	  
+          </listitem>
         </varlistentry>
         <varlistentry>
           <term>isValid ()</term>
       <programlisting>use XML::LibXML;
 my $compiled_xpath = XML::LibXML::XPathExpression-&gt;new('//foo[@bar="baz"][position()&lt;4]');
 
-# interface from XML::LibXML::Node 
+# interface from XML::LibXML::Node
 
 my $result = $node->find($compiled_xpath);
 my @nodes = $node->findnodes($compiled_xpath);
     </sect1>
     <sect1>
       <title>Description</title>
-      <para>This is a perl interface to libxml2's pre-compiled XPath expressions. 
+      <para>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. 
+      benefit if the same XPath query is evaluated many times.
       <function>XML::LibXML::XPathExpression</function> objects
-      can be passed to all <function>find...</function> 
+      can be passed to all <function>find...</function>
       functions <function>XML::LibXML</function>
       that expect an XPath expression.
       </para>
     <sect1>
       <title>Description</title>
       <para>This is a perl interface to libxml2's pattern matching support
-	<emphasis>http://xmlsoft.org/html/libxml-pattern.html</emphasis>. 
+	<emphasis>http://xmlsoft.org/html/libxml-pattern.html</emphasis>.
       This feature requires recent versions of libxml2.</para>
       <para>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
 	    <funcsynopsis>
 	      <funcsynopsisinfo>$bool = $pattern->matchesNode($node);</funcsynopsisinfo>
 	    </funcsynopsis>
-	    <para>Given a XML::LibXML::Node object, returns a true value if 
+	    <para>Given a XML::LibXML::Node object, returns a true value if
 	    the node is matched by the compiled pattern expression.</para>
 	  </listitem>
 	</varlistentry>
     <sect1>
       <title>SEE ALSO</title>
       <para><xref linkend="XML-LibXML-Reader"/> for other methods involving compiled patterns.</para>
-    </sect1>      
+    </sect1>
   </chapter>
   <chapter id="XML-LibXML-RegExp">
     <title>XML::LibXML::RegExp - interface to libxml2 regular expressions</title>
 	    <funcsynopsis>
 	      <funcsynopsisinfo>$compiled_re = XML::LibXML::RegExp-&gt;new( $regexp_str );</funcsynopsisinfo>
 	    </funcsynopsis>
-	    <para>The constructor takes a string containing a regular expression 
+	    <para>The constructor takes a string containing a regular expression
 	    and returns a compiled regexp object.
 	    </para>
 	  </listitem>
 	    <funcsynopsis>
 	      <funcsynopsisinfo>$bool = $compiled_re->matches($string);</funcsynopsisinfo>
 	    </funcsynopsis>
-	    <para>Given a string value, returns a true value if 
+	    <para>Given a string value, returns a true value if
 	    the value is matched by the compiled regular expression.</para>
 	  </listitem>
 	</varlistentry>
   </chapter>
   <chapter id="XML-LibXML-Error">
     <title>Structured Errors</title>
-    <titleabbrev>XML::LibXML::Error</titleabbrev> 
+    <titleabbrev>XML::LibXML::Error</titleabbrev>
     <sect1>
       <title>Synopsis</title>
       <programlisting>
 	    </funcsynopsis>
 	    <para>Traditionally, XML::LibXML was supressing parser
 	      warnings by setting libxml2's global variable
-	      xmlGetWarningsDefaultValue to 0. Since 
+	      xmlGetWarningsDefaultValue to 0. Since
 	      1.70 we do not change libxml2's global
 	      variables anymore; for backward compatibility,
 	      XML::LibXML suppresses warnings.
 	    <funcsynopsis>
 	      <funcsynopsisinfo>print $@->dump();</funcsynopsisinfo>
 	    </funcsynopsis>
-	    <para>This function serializes a XML::LibXML::Error to a 
+	    <para>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'.
 	    </para>
 	      "parser", "tree", "namespace", "validity", "HTML parser",
 	      "memory", "output", "I/O", "ftp", "http",
 	      "XInclude", "XPath", "xpointer", "regexp", "Schemas
-	      datatype", 
+	      datatype",
 	      "Schemas parser", "Schemas validity",
 	      "Relax-NG parser", "Relax-NG validity", "Catalog",
 	      "C14N", "XSLT", "validity".
   </chapter>
   <chapter id="XML-LibXML-ErrNo">
     <title>Structured Errors</title>
-    <titleabbrev>XML::LibXML::ErrNo</titleabbrev> 
-    <para>This module is based on xmlerror.h libxml2 C header file. 
+    <titleabbrev>XML::LibXML::ErrNo</titleabbrev>
+    <para>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.
   </chapter>
   <chapter id="XML-LibXML-Common">
     <title>Constants and Character Encoding Routines</title>
-    <titleabbrev>XML::LibXML::Common</titleabbrev> 
+    <titleabbrev>XML::LibXML::Common</titleabbrev>
     <sect1>
       <title>Synopsis</title>
       <programlisting>use XML::LibXML::Common;</programlisting>
       <para>
 	XML::LibXML::Common defines constants for all node types
 	and provides interface to libxml2 charset conversion
-	functions.	
+	functions.
       </para>
       <para>Since XML::LibXML use their own node type definitions,
       one may want to use XML::LibXML::Common in its compatibility
 	<title>Encoding functions</title>
 	<para>
 	  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 <literal>libxml2</literal>. 
+	  two functions, which provide interfact to the encoding support in <literal>libxml2</literal>.
 	  Which encodings are supported by these functions depends
 	  on how <literal>libxml2</literal> was compiled.  UTF-16 is
 	  always supported and on most installations, ISO encodings are