diff --git a/doc/FAQ.html b/doc/FAQ.html
index 1213039..f235429 100644
--- a/doc/FAQ.html
+++ b/doc/FAQ.html
@@ -105,9 +105,9 @@
   </li>
   <li>
 <em>Can I embed libxml in a proprietary application ?</em>
-    <p>Yes. The MIT License allows you to keep proprietary the changes
-    you made to libxml, but it would be graceful to send-back bug fixes
-    and improvements as patches for possible incorporation in the main
+    <p>Yes. The MIT License allows you to keep proprietary the changes you
+    made to libxml, but it would be graceful to send-back bug fixes and
+    improvements as patches for possible incorporation in the main
     development tree.</p>
   </li>
 </ol>
@@ -128,8 +128,8 @@
   <li>
 <em>I see libxml and libxml2 releases, which one should I install ?</em>
     <ul>
-<li>If you are not constrained by backward compatibility issues
-        with existing applications, install libxml2 only</li>
+<li>If you are not constrained by backward compatibility issues with
+        existing applications, install libxml2 only</li>
       <li>If you are not doing development, you can safely install both.
         Usually the packages <a href="http://rpmfind.net/linux/RPM/libxml.html">libxml</a> and <a href="http://rpmfind.net/linux/RPM/libxml2.html">libxml2</a> are
         compatible (this is not the case for development packages).</li>
@@ -145,8 +145,8 @@
   <li>
 <em>I can't install the libxml package, it conflicts with libxml0</em>
     <p>You probably have an old libxml0 package used to provide the shared
-    library for libxml.so.0, you can probably safely remove it. The
-    libxml packages provided on <a href="ftp://rpmfind.net/pub/libxml/">rpmfind.net</a> provide
+    library for libxml.so.0, you can probably safely remove it. The libxml
+    packages provided on <a href="ftp://rpmfind.net/pub/libxml/">rpmfind.net</a> provide
     libxml.so.0</p>
   </li>
   <li>
@@ -156,9 +156,9 @@
     rebuild it locally with</p>
     <p>
 <code>rpm --rebuild libxml(2)-xxx.src.rpm</code>.</p>
-    <p>If everything goes well it will generate two binary rpm packages (one providing
-    the shared libs and xmllint, and the other one, the -devel package,
-    providing includes, static libraries and scripts needed to build
+    <p>If everything goes well it will generate two binary rpm packages (one
+    providing the shared libs and xmllint, and the other one, the -devel
+    package, providing includes, static libraries and scripts needed to build
     applications with libxml(2)) that you can install locally.</p>
   </li>
 </ol>
@@ -197,17 +197,18 @@
 </li>
   <li>
 <em>Make check fails on some platforms</em>
-    <p>Sometimes the regression tests' results don't completely match the value
-    produced by the parser, and the makefile uses diff to print the delta. On
-    some platforms the diff return breaks the compilation process; if the
-    diff is small this is probably not a serious problem.</p>
+    <p>Sometimes the regression tests' results don't completely match the
+    value produced by the parser, and the makefile uses diff to print the
+    delta. On some platforms the diff return breaks the compilation process;
+    if the diff is small this is probably not a serious problem.</p>
     <p>Sometimes (especially on Solaris) make checks fail due to limitations
     in make. Try using GNU-make instead.</p>
   </li>
   <li>
 <em>I use the CVS version and there is no configure script</em>
-    <p>The configure script (and other Makefiles) are generated. Use the autogen.sh
-    script to regenerate the configure script and Makefiles, like:</p>
+    <p>The configure script (and other Makefiles) are generated. Use the
+    autogen.sh script to regenerate the configure script and Makefiles,
+    like:</p>
     <p><code>./autogen.sh --prefix=/usr --disable-shared</code></p>
   </li>
   <li>
@@ -293,8 +294,8 @@
     patches.</p>
   </li>
   <li>
-<em>Where can I get more examples and information than privoded on the web
-    page?</em>
+<em>Where can I get more examples and information than privoded on the
+    web page?</em>
     <p>Ideally a libxml book would be nice. I have no such plan ... But you
     can:</p>
     <ul>
@@ -311,9 +312,9 @@
       <li>
 <a href="http://cvs.gnome.org/bonsai/rview.cgi?cvsroot=/cvs/gnome&amp;dir=gnome-xml">Browse
         the libxml source</a> , I try to write code as clean and documented
-        as possible, so looking at it may be helpful. In particular the code of
-        xmllint.c and of the various testXXX.c test programs should provide
-        good examples of how to do things with the library.</li>
+        as possible, so looking at it may be helpful. In particular the code
+        of xmllint.c and of the various testXXX.c test programs should
+        provide good examples of how to do things with the library.</li>
     </ul>
 </li>
   <li>What about C++ ?
@@ -336,8 +337,8 @@
 </li>
   <li>How to validate a document a posteriori ?
     <p>It is possible to validate documents which had not been validated at
-    initial parsing time or documents which have been built from scratch using
-    the API. Use the <a href="http://xmlsoft.org/html/libxml-valid.html#XMLVALIDATEDTD">xmlValidateDtd()</a>
+    initial parsing time or documents which have been built from scratch
+    using the API. Use the <a href="http://xmlsoft.org/html/libxml-valid.html#XMLVALIDATEDTD">xmlValidateDtd()</a>
     function. It is also possible to simply add a DTD to an existing
     document:</p>
     <pre>xmlDocPtr doc; /* your existing document */
diff --git a/doc/XMLinfo.html b/doc/XMLinfo.html
index 4a327b9..b52a775 100644
--- a/doc/XMLinfo.html
+++ b/doc/XMLinfo.html
@@ -104,18 +104,19 @@
   &lt;/chapter&gt;
 &lt;/EXAMPLE&gt;</pre>
 <p>The first line specifies that it is an XML document and gives useful
-information about its encoding.  Then the rest of the document is a text format whose
-structure is specified by tags between brackets. <strong>Each tag opened has
-to be closed</strong>. XML is pedantic about this. However, if a tag is empty
-(no content), a single tag can serve as both the opening and closing tag if
-it ends with <code>/&gt;</code> rather than with <code>&gt;</code>. Note
-that, for example, the image tag has no content (just an attribute) and is
-closed by ending the tag with <code>/&gt;</code>.</p>
-<p>XML can be applied successfully to a wide range of tasks, ranging from long term
-structured document maintenance (where it follows the steps of SGML) to
-simple data encoding mechanisms like configuration file formatting (glade),
-spreadsheets (gnumeric), or even shorter lived documents such as WebDAV where
-it is used to encode remote calls between a client and a server.</p>
+information about its encoding.  Then the rest of the document is a text
+format whose structure is specified by tags between brackets. <strong>Each
+tag opened has to be closed</strong>. XML is pedantic about this. However, if
+a tag is empty (no content), a single tag can serve as both the opening and
+closing tag if it ends with <code>/&gt;</code> rather than with
+<code>&gt;</code>. Note that, for example, the image tag has no content (just
+an attribute) and is closed by ending the tag with <code>/&gt;</code>.</p>
+<p>XML can be applied successfully to a wide range of tasks, ranging from
+long term structured document maintenance (where it follows the steps of
+SGML) to simple data encoding mechanisms like configuration file formatting
+(glade), spreadsheets (gnumeric), or even shorter lived documents such as
+WebDAV where it is used to encode remote calls between a client and a
+server.</p>
 <p><a href="bugs.html">Daniel Veillard</a></p>
 </td></tr></table></td></tr></table></td></tr></table></td>
 </tr></table></td></tr></table>
diff --git a/doc/XSLT.html b/doc/XSLT.html
index a992816..f5842ad 100644
--- a/doc/XSLT.html
+++ b/doc/XSLT.html
@@ -93,8 +93,8 @@
 <a href="http://www.w3.org/TR/xslt">XSL Transformations</a>,  is a
 language for transforming XML documents into other XML documents (or
 HTML/textual output).</p>
-<p>A separate library called libxslt is being developed on top of libxml2. This
-module &quot;libxslt&quot; too can be found in the Gnome CVS base.</p>
+<p>A separate library called libxslt is being developed on top of libxml2.
+This module &quot;libxslt&quot; too can be found in the Gnome CVS base.</p>
 <p>You can check the <a href="http://cvs.gnome.org/lxr/source/libxslt/FEATURES">features</a>
 supported and the progresses on the <a href="http://cvs.gnome.org/lxr/source/libxslt/ChangeLog" name="Changelog">Changelog</a>.</p>
 <p><a href="bugs.html">Daniel Veillard</a></p>
diff --git a/doc/bugs.html b/doc/bugs.html
index 9f09957..de8ba50 100644
--- a/doc/bugs.html
+++ b/doc/bugs.html
@@ -90,9 +90,9 @@
 <p>Well, bugs or missing features are always possible, and I will make a
 point of fixing them in a timely fashion. The best way to report a bug is to
 use the <a href="http://bugzilla.gnome.org/buglist.cgi?product=libxml">Gnome
-bug tracking database</a> (make sure to use the &quot;libxml2&quot; module name). I look
-at reports there regularly and it's good to have a reminder when a bug is
-still open. Be sure to specify that the bug is for the package libxml2.</p>
+bug tracking database</a> (make sure to use the &quot;libxml2&quot; module name). I
+look at reports there regularly and it's good to have a reminder when a bug
+is still open. Be sure to specify that the bug is for the package libxml2.</p>
 <p>There is also a mailing-list <a href="mailto:xml@gnome.org">xml@gnome.org</a> for libxml, with an  <a href="http://mail.gnome.org/archives/xml/">on-line archive</a> (<a href="http://xmlsoft.org/messages">old</a>). To subscribe to this list,
 please visit the <a href="http://mail.gnome.org/mailman/listinfo/xml">associated Web</a> page and
 follow the instructions. <strong>Do not send code, I won't debug it</strong>
diff --git a/doc/docs.html b/doc/docs.html
index 58e2c81..e33042f 100644
--- a/doc/docs.html
+++ b/doc/docs.html
@@ -106,9 +106,9 @@
     for IBM developerWorks</a> about using libxml.</li>
   <li>Check <a href="http://cvs.gnome.org/lxr/source/gnome-xml/TODO">the TODO
     file</a>.</li>
-  <li>Read the <a href="upgrade.html">1.x to 2.x upgrade path</a> description. If you are
-    starting a new project using libxml you should really use the 2.x
-  version.</li>
+  <li>Read the <a href="upgrade.html">1.x to 2.x upgrade path</a>
+    description. If you are starting a new project using libxml you should
+    really use the 2.x version.</li>
   <li>And don't forget to look at the <a href="http://mail.gnome.org/archives/xml/">mailing-list archive</a>.</li>
 </ol>
 <p><a href="bugs.html">Daniel Veillard</a></p>
diff --git a/doc/downloads.html b/doc/downloads.html
index d9d3c4f..4fd7396 100644
--- a/doc/downloads.html
+++ b/doc/downloads.html
@@ -96,7 +96,9 @@
 maintainer of the Windows port, <a href="http://www.fh-frankfurt.de/~igor/projects/libxml/index.html">he
 provides binaries</a>. <a href="mailto:Gary.Pennington@sun.com">Gary
 Pennington</a> provides <a href="http://garypennington.net/libxml2/">Solaris
-binaries</a>. <a href="mailto:Steve.Ball@zveno.com">Steve Ball</a> provides <a href="http://www.zveno.com/open_source/libxml2xslt.html">Mac Os X binaries</a>.</p>
+binaries</a>. <a href="mailto:Steve.Ball@zveno.com">Steve Ball</a> provides
+<a href="http://www.zveno.com/open_source/libxml2xslt.html">Mac Os X
+binaries</a>.</p>
 <p><a name="Snapshot">Snapshot:</a></p>
 <ul>
 <li>Code from the W3C cvs base libxml <a href="ftp://xmlsoft.org/cvs-snapshot.tar.gz">cvs-snapshot.tar.gz</a>.</li>
diff --git a/doc/help.html b/doc/help.html
index b2f6ffb..a542b43 100644
--- a/doc/help.html
+++ b/doc/help.html
@@ -97,7 +97,8 @@
   and</li>
   <li>Provide documentation fixes (either as patches to the code comments or
     as HTML diffs).</li>
-  <li>Provide new documentations pieces (translations, examples, etc ...).</li>
+  <li>Provide new documentations pieces (translations, examples, etc
+  ...).</li>
   <li>Check the TODO file and try to close one of the items.</li>
   <li>Take one of the points raised in the archive or the bug database and
     provide a fix. <a href="mailto:daniel@veillard.com">Get in touch with me
diff --git a/doc/index.html b/doc/index.html
index f2d131a..d968c47 100644
--- a/doc/index.html
+++ b/doc/index.html
@@ -126,7 +126,8 @@
 </li>
 </ul>
 <p>In most cases libxml tries to implement the specifications in a relatively
-strictly compliant way. As of release 2.4.16, libxml2 passes all 1800+ tests from the <a href="http://www.oasis-open.org/committees/xml-conformance/">OASIS XML Tests
+strictly compliant way. As of release 2.4.16, libxml2 passes all 1800+ tests
+from the <a href="http://www.oasis-open.org/committees/xml-conformance/">OASIS XML Tests
 Suite</a>.</p>
 <p>To some extent libxml2 provides support for the following additional
 specifications but doesn't claim to implement them completely:</p>
diff --git a/doc/news.html b/doc/news.html
index 259190f..ba51d3e 100644
--- a/doc/news.html
+++ b/doc/news.html
@@ -96,6 +96,17 @@
     Schemas</a> and <a href="http://www.w3.org/TR/xinclude">XInclude</a>
 </li>
 </ul>
+<p><strong>2.4.24: Aug 22 2002</strong></p>
+<ul>
+<li>XPath fixes (William), xf:escape-uri() (Wesley Terpstra)</li>
+  <li>Python binding fixes: makefiles (William), generator, rpm build, x86-64
+    (fcrozat)</li>
+  <li>HTML &lt;style&gt; and boolean attributes serializer fixes</li>
+  <li>C14N improvements by Aleksey</li>
+  <li>doc cleanups: Rick Jones </li>
+  <li>Windows compiler makefile updates: Igor and Elizabeth Barham</li>
+  <li>XInclude: implementation of fallback and xml:base fixup added</li>
+</ul>
 <h3>2.4.23: July 6 2002</h3>
 <ul>
 <li>performances patches: Peter Jacobi</li>
diff --git a/doc/python.html b/doc/python.html
index 8507d84..ac1f57b 100644
--- a/doc/python.html
+++ b/doc/python.html
@@ -87,8 +87,8 @@
 </table>
 </td></tr></table></td>
 <td valign="top" bgcolor="#8b7765"><table border="0" cellspacing="0" cellpadding="1" width="100%"><tr><td><table border="0" cellspacing="0" cellpadding="1" width="100%" bgcolor="#000000"><tr><td><table border="0" cellpadding="3" cellspacing="1" width="100%"><tr><td bgcolor="#fffacd">
-<p>There are a number of language bindings and wrappers available for libxml2,
-the list below is not exhaustive. Please contact the <a href="http://mail.gnome.org/mailman/listinfo/xml-bindings">xml-bindings@gnome.org</a>
+<p>There are a number of language bindings and wrappers available for
+libxml2, the list below is not exhaustive. Please contact the <a href="http://mail.gnome.org/mailman/listinfo/xml-bindings">xml-bindings@gnome.org</a>
 (<a href="http://mail.gnome.org/archives/xml-bindings/">archives</a>) in
 order to get updates to this list or to discuss the specific topic of libxml2
 or libxslt wrappers or bindings:</p>
diff --git a/doc/xml.html b/doc/xml.html
index b80a56a..d87962d 100644
--- a/doc/xml.html
+++ b/doc/xml.html
@@ -58,7 +58,8 @@
 </ul>
 
 <p>In most cases libxml tries to implement the specifications in a relatively
-strictly compliant way. As of release 2.4.16, libxml2 passes all 1800+ tests from the <a
+strictly compliant way. As of release 2.4.16, libxml2 passes all 1800+ tests
+from the <a
 href="http://www.oasis-open.org/committees/xml-conformance/">OASIS XML Tests
 Suite</a>.</p>
 
@@ -159,9 +160,9 @@
     wording</p>
   </li>
   <li><em>Can I embed libxml in a proprietary application ?</em>
-    <p>Yes. The MIT License allows you to keep proprietary the changes
-    you made to libxml, but it would be graceful to send-back bug fixes
-    and improvements as patches for possible incorporation in the main
+    <p>Yes. The MIT License allows you to keep proprietary the changes you
+    made to libxml, but it would be graceful to send-back bug fixes and
+    improvements as patches for possible incorporation in the main
     development tree.</p>
   </li>
 </ol>
@@ -182,8 +183,8 @@
   </li>
   <li><em>I see libxml and libxml2 releases, which one should I install ?</em>
     <ul>
-      <li>If you are not constrained by backward compatibility issues
-        with existing applications, install libxml2 only</li>
+      <li>If you are not constrained by backward compatibility issues with
+        existing applications, install libxml2 only</li>
       <li>If you are not doing development, you can safely install both.
         Usually the packages <a
         href="http://rpmfind.net/linux/RPM/libxml.html">libxml</a> and <a
@@ -202,8 +203,8 @@
   </li>
   <li><em>I can't install the libxml package, it conflicts with libxml0</em>
     <p>You probably have an old libxml0 package used to provide the shared
-    library for libxml.so.0, you can probably safely remove it. The
-    libxml packages provided on <a
+    library for libxml.so.0, you can probably safely remove it. The libxml
+    packages provided on <a
     href="ftp://rpmfind.net/pub/libxml/">rpmfind.net</a> provide
     libxml.so.0</p>
   </li>
@@ -212,9 +213,9 @@
     <p>The most generic solution is to re-fetch the latest src.rpm , and
     rebuild it locally with</p>
     <p><code>rpm --rebuild libxml(2)-xxx.src.rpm</code>.</p>
-    <p>If everything goes well it will generate two binary rpm packages (one providing
-    the shared libs and xmllint, and the other one, the -devel package,
-    providing includes, static libraries and scripts needed to build
+    <p>If everything goes well it will generate two binary rpm packages (one
+    providing the shared libs and xmllint, and the other one, the -devel
+    package, providing includes, static libraries and scripts needed to build
     applications with libxml(2)) that you can install locally.</p>
   </li>
 </ol>
@@ -253,16 +254,17 @@
     </ul>
   </li>
   <li><em>Make check fails on some platforms</em>
-    <p>Sometimes the regression tests' results don't completely match the value
-    produced by the parser, and the makefile uses diff to print the delta. On
-    some platforms the diff return breaks the compilation process; if the
-    diff is small this is probably not a serious problem.</p>
+    <p>Sometimes the regression tests' results don't completely match the
+    value produced by the parser, and the makefile uses diff to print the
+    delta. On some platforms the diff return breaks the compilation process;
+    if the diff is small this is probably not a serious problem.</p>
     <p>Sometimes (especially on Solaris) make checks fail due to limitations
     in make. Try using GNU-make instead.</p>
   </li>
   <li><em>I use the CVS version and there is no configure script</em>
-    <p>The configure script (and other Makefiles) are generated. Use the autogen.sh
-    script to regenerate the configure script and Makefiles, like:</p>
+    <p>The configure script (and other Makefiles) are generated. Use the
+    autogen.sh script to regenerate the configure script and Makefiles,
+    like:</p>
     <p><code>./autogen.sh --prefix=/usr --disable-shared</code></p>
   </li>
   <li><em>I have troubles when running make tests with gcc-3.0</em>
@@ -345,8 +347,8 @@
     <p>Check the previous points 1/ and 2/ raised before, and please send
     patches.</p>
   </li>
-  <li><em>Where can I get more examples and information than privoded on the web
-    page?</em>
+  <li><em>Where can I get more examples and information than privoded on the
+    web page?</em>
     <p>Ideally a libxml book would be nice. I have no such plan ... But you
     can:</p>
     <ul>
@@ -363,9 +365,9 @@
       <li><a
         href="http://cvs.gnome.org/bonsai/rview.cgi?cvsroot=/cvs/gnome&amp;dir=gnome-xml">Browse
         the libxml source</a> , I try to write code as clean and documented
-        as possible, so looking at it may be helpful. In particular the code of
-        xmllint.c and of the various testXXX.c test programs should provide
-        good examples of how to do things with the library.</li>
+        as possible, so looking at it may be helpful. In particular the code
+        of xmllint.c and of the various testXXX.c test programs should
+        provide good examples of how to do things with the library.</li>
     </ul>
   </li>
   <li>What about C++ ?
@@ -388,8 +390,8 @@
   </li>
   <li>How to validate a document a posteriori ?
     <p>It is possible to validate documents which had not been validated at
-    initial parsing time or documents which have been built from scratch using
-    the API. Use the <a
+    initial parsing time or documents which have been built from scratch
+    using the API. Use the <a
     href="http://xmlsoft.org/html/libxml-valid.html#XMLVALIDATEDTD">xmlValidateDtd()</a>
     function. It is also possible to simply add a DTD to an existing
     document:</p>
@@ -430,9 +432,9 @@
     for IBM developerWorks</a> about using libxml.</li>
   <li>Check <a href="http://cvs.gnome.org/lxr/source/gnome-xml/TODO">the TODO
     file</a>.</li>
-  <li>Read the <a href="upgrade.html">1.x to 2.x upgrade path</a> description. If you are
-    starting a new project using libxml you should really use the 2.x
-  version.</li>
+  <li>Read the <a href="upgrade.html">1.x to 2.x upgrade path</a>
+    description. If you are starting a new project using libxml you should
+    really use the 2.x version.</li>
   <li>And don't forget to look at the <a
     href="http://mail.gnome.org/archives/xml/">mailing-list archive</a>.</li>
 </ol>
@@ -442,9 +444,9 @@
 <p>Well, bugs or missing features are always possible, and I will make a
 point of fixing them in a timely fashion. The best way to report a bug is to
 use the <a href="http://bugzilla.gnome.org/buglist.cgi?product=libxml">Gnome
-bug tracking database</a> (make sure to use the "libxml2" module name). I look
-at reports there regularly and it's good to have a reminder when a bug is
-still open. Be sure to specify that the bug is for the package libxml2.</p>
+bug tracking database</a> (make sure to use the "libxml2" module name). I
+look at reports there regularly and it's good to have a reminder when a bug
+is still open. Be sure to specify that the bug is for the package libxml2.</p>
 
 <p>There is also a mailing-list <a
 href="mailto:xml@gnome.org">xml@gnome.org</a> for libxml, with an  <a
@@ -502,7 +504,8 @@
   and</li>
   <li>Provide documentation fixes (either as patches to the code comments or
     as HTML diffs).</li>
-  <li>Provide new documentations pieces (translations, examples, etc ...).</li>
+  <li>Provide new documentations pieces (translations, examples, etc
+  ...).</li>
   <li>Check the TODO file and try to close one of the items.</li>
   <li>Take one of the points raised in the archive or the bug database and
     provide a fix. <a href="mailto:daniel@veillard.com">Get in touch with me
@@ -531,7 +534,9 @@
 href="http://www.fh-frankfurt.de/~igor/projects/libxml/index.html">he
 provides binaries</a>. <a href="mailto:Gary.Pennington@sun.com">Gary
 Pennington</a> provides <a href="http://garypennington.net/libxml2/">Solaris
-binaries</a>. <a href="mailto:Steve.Ball@zveno.com">Steve Ball</a> provides <a href="http://www.zveno.com/open_source/libxml2xslt.html">Mac Os X binaries</a>.</p>
+binaries</a>. <a href="mailto:Steve.Ball@zveno.com">Steve Ball</a> provides
+<a href="http://www.zveno.com/open_source/libxml2xslt.html">Mac Os X
+binaries</a>.</p>
 
 <p><a name="Snapshot">Snapshot:</a></p>
 <ul>
@@ -572,6 +577,18 @@
     Schemas</a> and <a href="http://www.w3.org/TR/xinclude">XInclude</a></li>
 </ul>
 
+<p><strong>2.4.24: Aug 22 2002</strong></p>
+<ul>
+  <li>XPath fixes (William), xf:escape-uri() (Wesley Terpstra)</li>
+  <li>Python binding fixes: makefiles (William), generator, rpm build, x86-64
+    (fcrozat)</li>
+  <li>HTML &lt;style&gt; and boolean attributes serializer fixes</li>
+  <li>C14N improvements by Aleksey</li>
+  <li>doc cleanups: Rick Jones </li>
+  <li>Windows compiler makefile updates: Igor and Elizabeth Barham</li>
+  <li>XInclude: implementation of fallback and xml:base fixup added</li>
+</ul>
+
 <h3>2.4.23: July 6 2002</h3>
 <ul>
   <li>performances patches: Peter Jacobi</li>
@@ -1370,19 +1387,20 @@
 &lt;/EXAMPLE&gt;</pre>
 
 <p>The first line specifies that it is an XML document and gives useful
-information about its encoding.  Then the rest of the document is a text format whose
-structure is specified by tags between brackets. <strong>Each tag opened has
-to be closed</strong>. XML is pedantic about this. However, if a tag is empty
-(no content), a single tag can serve as both the opening and closing tag if
-it ends with <code>/&gt;</code> rather than with <code>&gt;</code>. Note
-that, for example, the image tag has no content (just an attribute) and is
-closed by ending the tag with <code>/&gt;</code>.</p>
+information about its encoding.  Then the rest of the document is a text
+format whose structure is specified by tags between brackets. <strong>Each
+tag opened has to be closed</strong>. XML is pedantic about this. However, if
+a tag is empty (no content), a single tag can serve as both the opening and
+closing tag if it ends with <code>/&gt;</code> rather than with
+<code>&gt;</code>. Note that, for example, the image tag has no content (just
+an attribute) and is closed by ending the tag with <code>/&gt;</code>.</p>
 
-<p>XML can be applied successfully to a wide range of tasks, ranging from long term
-structured document maintenance (where it follows the steps of SGML) to
-simple data encoding mechanisms like configuration file formatting (glade),
-spreadsheets (gnumeric), or even shorter lived documents such as WebDAV where
-it is used to encode remote calls between a client and a server.</p>
+<p>XML can be applied successfully to a wide range of tasks, ranging from
+long term structured document maintenance (where it follows the steps of
+SGML) to simple data encoding mechanisms like configuration file formatting
+(glade), spreadsheets (gnumeric), or even shorter lived documents such as
+WebDAV where it is used to encode remote calls between a client and a
+server.</p>
 
 <h2><a name="XSLT">XSLT</a></h2>
 
@@ -1392,8 +1410,8 @@
 language for transforming XML documents into other XML documents (or
 HTML/textual output).</p>
 
-<p>A separate library called libxslt is being developed on top of libxml2. This
-module "libxslt" too can be found in the Gnome CVS base.</p>
+<p>A separate library called libxslt is being developed on top of libxml2.
+This module "libxslt" too can be found in the Gnome CVS base.</p>
 
 <p>You can check the <a
 href="http://cvs.gnome.org/lxr/source/libxslt/FEATURES">features</a>
@@ -1403,8 +1421,8 @@
 
 <h2><a name="Python">Python and bindings</a></h2>
 
-<p>There are a number of language bindings and wrappers available for libxml2,
-the list below is not exhaustive. Please contact the <a
+<p>There are a number of language bindings and wrappers available for
+libxml2, the list below is not exhaustive. Please contact the <a
 href="http://mail.gnome.org/mailman/listinfo/xml-bindings">xml-bindings@gnome.org</a>
 (<a href="http://mail.gnome.org/archives/xml-bindings/">archives</a>) in
 order to get updates to this list or to discuss the specific topic of libxml2
@@ -1897,8 +1915,8 @@
 found within your document, what is the formal shape of your document tree
 (by defining the allowed content of an element; either text, a regular
 expression for the allowed list of children, or mixed content i.e. both text
-and children). The DTD also defines the valid attributes for all elements
-and the types of those attributes.</p>
+and children). The DTD also defines the valid attributes for all elements and
+the types of those attributes.</p>
 
 <h3><a name="definition1">The definition</a></h3>
 
@@ -1917,10 +1935,10 @@
 
 <h3><a name="Simple1">Simple rules</a></h3>
 
-<p>Writing DTDs can be done in many ways. The rules to build them if you
-need something permanent or something which can evolve over time can be radically
-different. Really complex DTDs like DocBook ones are flexible but quite harder
-to design. I will just focus on DTDs for a formats with a fixed simple
+<p>Writing DTDs can be done in many ways. The rules to build them if you need
+something permanent or something which can evolve over time can be radically
+different. Really complex DTDs like DocBook ones are flexible but quite
+harder to design. I will just focus on DTDs for a formats with a fixed simple
 structure. It is just a set of basic rules, and definitely not exhaustive nor
 usable for complex DTD design.</p>
 
@@ -2027,9 +2045,9 @@
 <h3><a name="Some1">Some examples</a></h3>
 
 <p>The directory <code>test/valid/dtds/</code> in the libxml distribution
-contains some complex DTD examples. The example in the file <code>test/valid/dia.xml</code>
-shows an XML file where the simple DTD is directly included within
-the document.</p>
+contains some complex DTD examples. The example in the file
+<code>test/valid/dia.xml</code> shows an XML file where the simple DTD is
+directly included within the document.</p>
 
 <h3><a name="validate1">How to validate</a></h3>
 
@@ -2042,8 +2060,8 @@
 
 <p>the -- noout is used to disable output of the resulting tree.</p>
 
-<p>The <code>--dtdvalid dtd</code> allows validation of the document(s) against
-a given DTD.</p>
+<p>The <code>--dtdvalid dtd</code> allows validation of the document(s)
+against a given DTD.</p>
 
 <p>Libxml exports an API to handle DTDs and validation, check the <a
 href="http://xmlsoft.org/html/libxml-valid.html">associated
@@ -2644,6 +2662,7 @@
 
 
 
+
 } </pre>
   </li>
   <li>And then use it to save the document:
diff --git a/doc/xmldtd.html b/doc/xmldtd.html
index de4f48a..d266b8a 100644
--- a/doc/xmldtd.html
+++ b/doc/xmldtd.html
@@ -116,8 +116,8 @@
 found within your document, what is the formal shape of your document tree
 (by defining the allowed content of an element; either text, a regular
 expression for the allowed list of children, or mixed content i.e. both text
-and children). The DTD also defines the valid attributes for all elements
-and the types of those attributes.</p>
+and children). The DTD also defines the valid attributes for all elements and
+the types of those attributes.</p>
 <h3><a name="definition1">The definition</a></h3>
 <p>The <a href="http://www.w3.org/TR/REC-xml">W3C XML Recommendation</a> (<a href="http://www.xml.com/axml/axml.html">Tim Bray's annotated version of
 Rev1</a>):</p>
@@ -130,10 +130,10 @@
 <p>(unfortunately) all this is inherited from the SGML world, the syntax is
 ancient...</p>
 <h3><a name="Simple1">Simple rules</a></h3>
-<p>Writing DTDs can be done in many ways. The rules to build them if you
-need something permanent or something which can evolve over time can be radically
-different. Really complex DTDs like DocBook ones are flexible but quite harder
-to design. I will just focus on DTDs for a formats with a fixed simple
+<p>Writing DTDs can be done in many ways. The rules to build them if you need
+something permanent or something which can evolve over time can be radically
+different. Really complex DTDs like DocBook ones are flexible but quite
+harder to design. I will just focus on DTDs for a formats with a fixed simple
 structure. It is just a set of basic rules, and definitely not exhaustive nor
 usable for complex DTD design.</p>
 <h4>
@@ -218,9 +218,9 @@
 </ul>
 <h3><a name="Some1">Some examples</a></h3>
 <p>The directory <code>test/valid/dtds/</code> in the libxml distribution
-contains some complex DTD examples. The example in the file <code>test/valid/dia.xml</code>
-shows an XML file where the simple DTD is directly included within
-the document.</p>
+contains some complex DTD examples. The example in the file
+<code>test/valid/dia.xml</code> shows an XML file where the simple DTD is
+directly included within the document.</p>
 <h3><a name="validate1">How to validate</a></h3>
 <p>The simplest way is to use the xmllint program included with libxml. The
 <code>--valid</code> option turns-on validation of the files given as input.
@@ -228,8 +228,8 @@
 1.0 specification:</p>
 <p><code>xmllint --valid --noout test/valid/REC-xml-19980210.xml</code></p>
 <p>the -- noout is used to disable output of the resulting tree.</p>
-<p>The <code>--dtdvalid dtd</code> allows validation of the document(s) against
-a given DTD.</p>
+<p>The <code>--dtdvalid dtd</code> allows validation of the document(s)
+against a given DTD.</p>
 <p>Libxml exports an API to handle DTDs and validation, check the <a href="http://xmlsoft.org/html/libxml-valid.html">associated
 description</a>.</p>
 <h3><a name="Other1">Other resources</a></h3>
diff --git a/doc/xmlio.html b/doc/xmlio.html
index cf218d9..e650161 100644
--- a/doc/xmlio.html
+++ b/doc/xmlio.html
@@ -238,6 +238,7 @@
 
 
 
+
 } </pre>
   </li>
   <li>And then use it to save the document:
